nothumanallowed 14.3.9 → 14.4.1

package/package.json

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

package/src/server/routes/connectors.mjs

@@ -38,6 +38,92 @@ function deleteWorkflow(id) {
   if (fs.existsSync(p)) fs.unlinkSync(p);
 }
 
+/** Seed example workflows on first run */
+function seedExamples() {
+  ensureDir();
+  const marker = path.join(WORKFLOWS_DIR, '.examples-seeded');
+  if (fs.existsSync(marker)) return;
+
+  const examples = [
+    {
+      id: 'ex_email_digest', name: '📧 Daily Email Digest',
+      enabled: false,
+      nodes: [
+        { id: 'n1', defId: 'trigger_cron', x: 40, y: 80, config: { schedule: '0 8 * * *' } },
+        { id: 'n2', defId: 'ai_summarize', x: 200, y: 80, config: { prompt: 'Summarize the last 10 unread emails concisely: {{output}}' } },
+        { id: 'n3', defId: 'action_slack', x: 400, y: 40, config: { channel: '#general', text: '📧 Morning Digest:\n{{output}}' } },
+        { id: 'n4', defId: 'action_notify', x: 400, y: 140, config: { message: 'Email digest ready', channel: 'system' } },
+      ],
+      edges: [{ from: 'n1', to: 'n2' }, { from: 'n2', to: 'n3' }, { from: 'n2', to: 'n4' }],
+    },
+    {
+      id: 'ex_smart_router', name: '🔀 Smart Email Router',
+      enabled: false,
+      nodes: [
+        { id: 'n1', defId: 'trigger_email', x: 40, y: 100, config: { filter: 'is:unread' } },
+        { id: 'n2', defId: 'ai_classify', x: 200, y: 100, config: { categories: 'urgent, meeting, newsletter, spam', prompt: 'Classify this email: {{output}}' } },
+        { id: 'n3', defId: 'logic_if', x: 380, y: 100, config: { condition: 'output.includes("urgent")' } },
+        { id: 'n4', defId: 'action_notify', x: 560, y: 40, config: { message: '🚨 Urgent email: {{output}}', channel: 'telegram' } },
+        { id: 'n5', defId: 'action_task', x: 560, y: 160, config: { title: 'Review: {{output}}', priority: 'low' } },
+      ],
+      edges: [
+        { from: 'n1', to: 'n2' }, { from: 'n2', to: 'n3' },
+        { from: 'n3', to: 'n4', fromPort: 'true' },
+        { from: 'n3', to: 'n5', fromPort: 'false' },
+      ],
+    },
+    {
+      id: 'ex_content_pipeline', name: '📝 Content Pipeline',
+      enabled: false,
+      nodes: [
+        { id: 'n1', defId: 'trigger_manual', x: 40, y: 100, config: { input: 'Write a blog post about AI agents' } },
+        { id: 'n2', defId: 'ai_agent', x: 200, y: 100, config: { agent: 'quill', prompt: 'Write a professional blog post about: {{output}}' } },
+        { id: 'n3', defId: 'ai_translate', x: 400, y: 40, config: { lang: 'Italian', prompt: '{{output}}' } },
+        { id: 'n4', defId: 'action_drive', x: 600, y: 40, config: { name: 'blog-it.md', content: '{{output}}' } },
+        { id: 'n5', defId: 'action_drive', x: 400, y: 160, config: { name: 'blog-en.md', content: '{{output}}' } },
+      ],
+      edges: [{ from: 'n1', to: 'n2' }, { from: 'n2', to: 'n3' }, { from: 'n2', to: 'n5' }, { from: 'n3', to: 'n4' }],
+    },
+    {
+      id: 'ex_meeting_prep', name: '📅 Meeting Prep Automation',
+      enabled: false,
+      nodes: [
+        { id: 'n1', defId: 'trigger_cron', x: 40, y: 100, config: { schedule: '0 7 * * 1-5' } },
+        { id: 'n2', defId: 'ai_agent', x: 200, y: 100, config: { agent: 'herald', prompt: 'List my meetings for today with details' } },
+        { id: 'n3', defId: 'logic_if', x: 380, y: 100, config: { condition: 'output.length > 20' } },
+        { id: 'n4', defId: 'ai_summarize', x: 540, y: 40, config: { prompt: 'Prepare a brief for each meeting. Include talking points: {{output}}' } },
+        { id: 'n5', defId: 'action_email', x: 720, y: 40, config: { to: 'me', subject: '📅 Meeting Prep — Today', body: '{{output}}' } },
+      ],
+      edges: [
+        { from: 'n1', to: 'n2' }, { from: 'n2', to: 'n3' },
+        { from: 'n3', to: 'n4', fromPort: 'true' },
+      ],
+    },
+    {
+      id: 'ex_web_monitor', name: '🌐 Website Monitor + Alert',
+      enabled: false,
+      nodes: [
+        { id: 'n1', defId: 'trigger_cron', x: 40, y: 100, config: { schedule: '*/30 * * * *' } },
+        { id: 'n2', defId: 'action_webhook', x: 200, y: 100, config: { url: 'https://nothumanallowed.com', method: 'GET' } },
+        { id: 'n3', defId: 'logic_if', x: 380, y: 100, config: { condition: 'output.includes("Error") || output.length < 100' } },
+        { id: 'n4', defId: 'action_notify', x: 560, y: 40, config: { message: '🚨 Website down or error detected!', channel: 'telegram' } },
+        { id: 'n5', defId: 'logic_error', x: 560, y: 160, config: { retries: '2', fallback: 'Check failed — site may be unreachable' } },
+      ],
+      edges: [
+        { from: 'n1', to: 'n2' }, { from: 'n2', to: 'n3' },
+        { from: 'n3', to: 'n4', fromPort: 'true' },
+        { from: 'n3', to: 'n5', fromPort: 'false' },
+      ],
+    },
+  ];
+
+  for (const wf of examples) {
+    const p = path.join(WORKFLOWS_DIR, `${wf.id}.json`);
+    if (!fs.existsSync(p)) fs.writeFileSync(p, JSON.stringify(wf, null, 2));
+  }
+  fs.writeFileSync(marker, new Date().toISOString());
+}
+
 /** Substitute {{varName}} placeholders in a string using a context map */
 function interpolate(str, ctx) {
   if (typeof str !== 'string') return str;
@@ -61,24 +147,81 @@ function interpolateObj(obj, ctx) {
 async function executeNode(node, nodeDef, ctx, config) {
   const cfg = interpolateObj(node.config ?? {}, ctx);
 
-  // AI nodes
+  // ── AI nodes ──
   if (nodeDef.type === 'ai') {
+    if (node.defId === 'ai_code') {
+      // Code node — execute JS with `input` variable
+      try {
+        const fn = new Function('input', 'output', 'ctx', cfg.code || 'return input;');
+        const result = fn(ctx.output || '', ctx.output || '', ctx);
+        return String(result ?? '');
+      } catch (e) { throw new Error(`Code error: ${e.message}`); }
+    }
     const prompt = cfg.prompt || `Process this: ${ctx.output || ''}`;
-    const systemPrompt = cfg.systemPrompt || 'You are a helpful AI assistant. Process the input and return a concise result.';
+    const agentName = cfg.agent || '';
+    const systemPrompt = agentName
+      ? `You are ${agentName}, a specialist AI agent. Process the input and return a concise result.`
+      : 'You are a helpful AI assistant. Process the input and return a concise result.';
     const result = await callLLM(config, systemPrompt, prompt);
     return result?.content || result || '';
   }
 
-  // Action nodes — map to executeTool actions
+  // ── Logic nodes ──
+  if (nodeDef.type === 'logic') {
+    if (node.defId === 'logic_if') {
+      try {
+        const fn = new Function('output', 'input', 'ctx', `return Boolean(${cfg.condition || 'false'});`);
+        const result = fn(ctx.output || '', ctx.output || '', ctx);
+        return JSON.stringify({ __branch: result ? 'true' : 'false', value: ctx.output || '' });
+      } catch (e) { throw new Error(`Condition error: ${e.message}`); }
+    }
+    if (node.defId === 'logic_switch') {
+      const expr = cfg.expression || ctx.output || '';
+      const cases = (cfg.cases || '').split(',').map((c) => c.trim());
+      const matched = cases.find((c) => expr.toLowerCase().includes(c.toLowerCase()));
+      return JSON.stringify({ __branch: matched || 'default', value: ctx.output || '' });
+    }
+    if (node.defId === 'logic_loop') {
+      const sep = cfg.separator === ',' ? ',' : '\n';
+      const items = (ctx.output || '').split(sep).filter(Boolean);
+      return JSON.stringify({ __loop: true, items, count: items.length });
+    }
+    if (node.defId === 'logic_merge') {
+      // Merge collects from ctx.__mergeInputs (set by the executor)
+      const inputs = ctx.__mergeInputs || [ctx.output || ''];
+      if (cfg.mode === 'json_array') return JSON.stringify(inputs);
+      if (cfg.mode === 'first_non_empty') return inputs.find((i) => i && i.trim()) || '';
+      return inputs.join('\n');
+    }
+    if (node.defId === 'logic_delay') {
+      const ms = Math.min(parseInt(cfg.seconds || '1') * 1000, 60_000);
+      await new Promise((r) => setTimeout(r, ms));
+      return ctx.output || '';
+    }
+    if (node.defId === 'logic_error') {
+      // Error handler wraps previous node execution — handled in runWorkflow
+      return ctx.output || cfg.fallback || '';
+    }
+    return ctx.output || '';
+  }
+
+  // ── Action nodes ──
   const ACTION_MAP = {
-    action_email:    ['gmail_send',       { to: cfg.to, subject: cfg.subject || 'NHA Workflow', body: cfg.body || ctx.output }],
-    action_slack:    ['slack_message',    { channel: cfg.channel || '#general', text: cfg.text || ctx.output }],
-    action_calendar: ['calendar_create',  { title: cfg.title || ctx.output, date: cfg.date || new Date().toISOString().split('T')[0], time: cfg.time || '09:00', duration: cfg.duration || '60' }],
-    action_task:     ['task_create',      { title: cfg.title || ctx.output, priority: cfg.priority || 'medium' }],
-    action_drive:    ['drive_upload',     { name: cfg.name || 'workflow-output.txt', content: cfg.content || ctx.output }],
-    action_notion:   ['notion_page',      { title: cfg.title || 'Workflow Output', content: cfg.content || ctx.output }],
-    action_github:   ['github_issue',     { repo: cfg.repo, title: cfg.title || ctx.output, body: cfg.body || '' }],
-    action_webhook:  ['fetch_url',        { url: cfg.url, method: cfg.method || 'POST', body: cfg.body || ctx.output }],
+    action_email:      ['gmail_send',       { to: cfg.to, subject: cfg.subject || 'NHA Workflow', body: cfg.body || ctx.output }],
+    action_slack:      ['slack_message',    { channel: cfg.channel || '#general', text: cfg.text || ctx.output }],
+    action_calendar:   ['calendar_create',  { title: cfg.title || ctx.output, date: cfg.date || new Date().toISOString().split('T')[0], time: cfg.time || '09:00', duration: cfg.duration || '60' }],
+    action_task:       ['task_create',      { title: cfg.title || ctx.output, priority: cfg.priority || 'medium' }],
+    action_drive:      ['drive_upload',     { name: cfg.name || 'workflow-output.txt', content: cfg.content || ctx.output }],
+    action_notion:     ['notion_page',      { title: cfg.title || 'Workflow Output', content: cfg.content || ctx.output }],
+    action_github:     ['github_issue',     { repo: cfg.repo, title: cfg.title || ctx.output, body: cfg.body || '' }],
+    action_webhook:    ['fetch_url',        { url: cfg.url, method: cfg.method || 'POST', body: cfg.body || ctx.output }],
+    action_browser:    ['browser_open',     { url: cfg.url || ctx.output }],
+    action_file_read:  ['file_read',        { path: cfg.path }],
+    action_file_write: ['file_write',       { path: cfg.path, content: cfg.content || ctx.output }],
+    action_contact:    ['contact_search',   { query: cfg.query || ctx.output }],
+    action_screen:     ['screen_capture',   {}],
+    action_maps:       ['maps_directions',  { from: cfg.from, to: cfg.to }],
+    action_notify:     ['notify_remind',    { message: cfg.message || ctx.output, channel: cfg.channel || 'system' }],
   };
 
   const mapped = ACTION_MAP[node.defId];
@@ -91,7 +234,7 @@ async function executeNode(node, nodeDef, ctx, config) {
     }
   }
 
-  // Trigger nodes produce no output themselves (they're the entry point)
+  // Trigger nodes
   if (nodeDef.type === 'trigger') {
     return ctx.output || cfg.input || '';
   }
@@ -108,19 +251,25 @@ async function runWorkflow(wf, initialInput, config) {
   const nodeMap = Object.fromEntries(wf.nodes.map((n) => [n.id, n]));
   const defMap = Object.fromEntries((wf.nodeDefs || []).map((d) => [d.id, d]));
 
-  // Build adjacency: from → to
+  // Build adjacency: from → [{to, fromPort}]
   const next = {};
   for (const e of wf.edges ?? []) {
     if (!next[e.from]) next[e.from] = [];
-    next[e.from].push(e.to);
+    next[e.from].push({ to: e.to, port: e.fromPort || 'default' });
   }
 
-  // Find start node (trigger, or first with no incoming edges)
+  // Check if next node is an error handler
+  const isErrorHandler = (nodeId) => {
+    const n = nodeMap[nodeId];
+    return n?.defId === 'logic_error';
+  };
+
+  // Find start nodes
   const hasIncoming = new Set((wf.edges ?? []).map((e) => e.to));
   const startCandidates = wf.nodes.filter((n) => !hasIncoming.has(n.id));
-  if (startCandidates.length === 0) return [{ nodeId: '__error', output: 'No start node found.' }];
+  if (startCandidates.length === 0) return [{ nodeId: '__error', nodeLabel: 'Error', nodeIcon: '❌', output: 'No start node found.' }];
 
-  // BFS execution
+  // BFS execution with branching support
   const queue = startCandidates.map((n) => ({ nodeId: n.id, ctx: { output: initialInput || '', input: initialInput || '' } }));
   const visited = new Set();
 
@@ -136,18 +285,75 @@ async function runWorkflow(wf, initialInput, config) {
 
     let output = '';
     let error = null;
-    try {
-      output = await executeNode(node, nodeDef, ctx, config);
-    } catch (e) {
-      error = e.message;
-      output = '';
+
+    // Error handler: wrap with retry
+    const maxRetries = node.defId === 'logic_error' ? parseInt(node.config?.retries || '0') : 0;
+    let attempt = 0;
+    while (attempt <= maxRetries) {
+      try {
+        output = await executeNode(node, nodeDef, ctx, config);
+        error = null;
+        break;
+      } catch (e) {
+        error = e.message;
+        output = node.config?.fallback || '';
+        attempt++;
+        if (attempt <= maxRetries) {
+          steps.push({ nodeId, nodeLabel: nodeDef.label, nodeIcon: '🔄', output: `Retry ${attempt}/${maxRetries}: ${e.message}`, error: null });
+        }
+      }
     }
 
-    steps.push({ nodeId, nodeLabel: nodeDef.label, nodeIcon: nodeDef.icon, output, error });
+    steps.push({ nodeId, nodeLabel: nodeDef.label, nodeIcon: nodeDef.icon, output: output?.slice?.(0, 2000) || '', error });
 
-    const nextCtx = { ...ctx, output, [`${nodeDef.id}_output`]: output };
-    for (const toId of next[nodeId] ?? []) {
-      queue.push({ nodeId: toId, ctx: nextCtx });
+    // If error and no error handler downstream, stop this branch
+    if (error) {
+      const hasHandler = (next[nodeId] ?? []).some((n) => isErrorHandler(n.to));
+      if (!hasHandler) continue;
+    }
+
+    // Determine which downstream nodes to execute based on branching
+    const downstream = next[nodeId] ?? [];
+    let branch = null;
+    try {
+      const parsed = JSON.parse(output || '{}');
+      if (parsed.__branch) branch = parsed.__branch;
+      if (parsed.__loop && Array.isArray(parsed.items)) {
+        // Loop: execute downstream for each item
+        for (const item of parsed.items) {
+          const loopCtx = { ...ctx, output: item, loopItem: item };
+          for (const { to: toId } of downstream) {
+            // Don't mark as visited — allow loop iterations
+            const toNode = nodeMap[toId];
+            if (!toNode) continue;
+            const toDef = defMap[toNode.defId];
+            if (!toDef) continue;
+            try {
+              const loopOut = await executeNode(toNode, toDef, loopCtx, config);
+              steps.push({ nodeId: toId, nodeLabel: `${toDef.label} [${item.slice(0, 20)}]`, nodeIcon: toDef.icon, output: loopOut?.slice?.(0, 2000) || '', error: null });
+            } catch (e) {
+              steps.push({ nodeId: toId, nodeLabel: `${toDef.label} [${item.slice(0, 20)}]`, nodeIcon: toDef.icon, output: '', error: e.message });
+            }
+          }
+        }
+        continue; // Loop handles its own downstream
+      }
+    } catch { /* not JSON — no branching */ }
+
+    const nextCtx = { ...ctx, output: output || '', [`${node.defId}_output`]: output || '' };
+
+    if (branch) {
+      // Branching: only follow edges that match the branch port
+      for (const { to: toId, port } of downstream) {
+        if (port === branch || port === 'default') {
+          queue.push({ nodeId: toId, ctx: nextCtx });
+        }
+      }
+    } else {
+      // Normal: follow all downstream edges
+      for (const { to: toId } of downstream) {
+        queue.push({ nodeId: toId, ctx: nextCtx });
+      }
     }
   }
 
@@ -158,6 +364,7 @@ export function register(router) {
   // GET /api/workflows — list all workflows
   router.get('/api/workflows', async (req, res) => {
     try {
+      seedExamples();
       sendJSON(res, 200, { workflows: listWorkflows() });
     } catch (e) {
       sendError(res, 500, e.message);

package/src/server/routes/webcraft.mjs

@@ -1033,7 +1033,8 @@ RULES:
 
 const FILE_PLAN_SYSTEM = `You are the lead architect of a 200-person engineering team. Design an ENTERPRISE-GRADE file structure.
 Output ONLY a JSON array: [{"name":"path/to/file.ext","purpose":"detailed description","tokens":N}]
-where "tokens" is your estimate of content tokens (300-800 small, 1000-2500 medium, 2500-5000 large).
+where "tokens" is your estimate of content tokens (200-600 small, 600-1500 medium, 1500-3000 large).
+CRITICAL: No single file should exceed 3000 tokens. Split large files into smaller modules.
 
 MANDATORY STRUCTURE (every project MUST have):
 - package.json (with ALL dependencies: express, helmet, cors, compression, morgan, bcryptjs, jsonwebtoken, express-rate-limit, cookie-parser, dotenv)
@@ -1062,7 +1063,11 @@ MANDATORY STRUCTURE (every project MUST have):
 - public/js/animations.js (intersection observer, scroll effects)
 
 RULES:
-- Generate 25-45 files — real enterprise projects have many files
+- Generate 30-50 files — many small files are better than few large ones
+- NEVER generate a file larger than 200 lines. Split into components/partials instead
+- HTML pages: use <script src="js/page.js"> and <link href="css/page.css"> — NOT inline
+- CSS: one file per concern (max 150 lines each), NOT one giant file
+- JS: one file per feature (max 150 lines each)
 - Token estimates must be realistic: CSS files 1500-3000, JS files 1000-2000, HTML pages 2000-4000
 - Use relative paths only
 - No explanation, no markdown, ONLY the JSON array.`;
@@ -1285,9 +1290,9 @@ Design a COMPLETE production-ready file structure. Include ALL files needed for
       })
       .join('\n\n');
 
-    // Generous max_tokens — enterprise files are large
-    const estimatedTokens = fileSpec.tokens || 2000;
-    const maxTokens = Math.min(Math.max(estimatedTokens * 3, 4000), 16384);
+    // max_tokens scaled to file size — smaller files = less truncation risk
+    const estimatedTokens = fileSpec.tokens || 1500;
+    const maxTokens = Math.min(Math.max(estimatedTokens * 2, 2000), 8192);
 
     const fileSys = `You are a team of 200 senior full-stack developers generating ENTERPRISE-GRADE production code.
 
@@ -1321,7 +1326,9 @@ FRONTEND STANDARDS:
 - Accessible: aria-labels, focus styles, keyboard navigation, alt text
 - Professional typography: system font stack, proper hierarchy (clamp() for fluid sizes)
 - CSS Grid/Flexbox layouts — no floats
-- At minimum 500 lines for main CSS files, 200+ lines for page JS files`;
+- Each file must be COMPLETE and SELF-CONTAINED — no truncation
+- Maximum 200 lines per file. If more content needed, split into separate files
+- HTML: external CSS/JS via link/script tags, NOT inline styles/scripts exceeding 20 lines`;
 
     const filePrompt = `Project: ${projectName}
 Description: ${description}