nothumanallowed 15.1.38 → 15.1.40

package/package.json

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

package/src/server/routes/connectors.mjs

@@ -2,19 +2,31 @@
  * Connectors — visual workflow automation backend
  * Workflows stored in ~/.nha/workflows/*.json
  * Execution: each node runs a real NHA tool or AI call
+ *
+ * 15.1.40 — closes the gap vs n8n:
+ *   • Workflow versioning (auto-snapshot on each save)
+ *   • Webhook triggers (HTTP endpoint per workflow)
+ *   • Credentials manager (AES-256-GCM at rest, ${cred.NAME} interpolation)
+ *   • Subworkflows (one workflow can call another)
  */
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
+import crypto from 'crypto';
 import { NHA_DIR } from '../../constants.mjs';
 import { loadConfig } from '../../config.mjs';
 import { sendJSON, sendError, parseBody } from '../index.mjs';
 import { executeTool } from '../../services/tool-executor.mjs';
 import { callLLM } from '../../services/llm.mjs';
 
-const WORKFLOWS_DIR = path.join(NHA_DIR, 'workflows');
+const WORKFLOWS_DIR  = path.join(NHA_DIR, 'workflows');
+const VERSIONS_DIR   = path.join(NHA_DIR, 'workflows', '_versions');
+const CREDS_FILE     = path.join(NHA_DIR, 'credentials.json');
+const MAX_VERSIONS_PER_WF = 50;
 
 function ensureDir() {
   if (!fs.existsSync(WORKFLOWS_DIR)) fs.mkdirSync(WORKFLOWS_DIR, { recursive: true });
+  if (!fs.existsSync(VERSIONS_DIR))  fs.mkdirSync(VERSIONS_DIR,  { recursive: true });
 }
 
 function listWorkflows() {
@@ -30,12 +42,144 @@ function listWorkflows() {
 
 function saveWorkflow(wf) {
   ensureDir();
-  fs.writeFileSync(path.join(WORKFLOWS_DIR, `${wf.id}.json`), JSON.stringify(wf, null, 2));
+  const file = path.join(WORKFLOWS_DIR, `${wf.id}.json`);
+  // 1. Snapshot previous version BEFORE overwriting — that's how we get
+  //    a real history viewer like n8n's. Pruned to MAX_VERSIONS_PER_WF.
+  if (fs.existsSync(file)) {
+    const wfVersionsDir = path.join(VERSIONS_DIR, wf.id);
+    if (!fs.existsSync(wfVersionsDir)) fs.mkdirSync(wfVersionsDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    try {
+      const prev = fs.readFileSync(file, 'utf-8');
+      fs.writeFileSync(path.join(wfVersionsDir, `${ts}.json`), prev);
+      // Prune oldest
+      const versions = fs.readdirSync(wfVersionsDir).filter((f) => f.endsWith('.json')).sort();
+      while (versions.length > MAX_VERSIONS_PER_WF) {
+        try { fs.unlinkSync(path.join(wfVersionsDir, versions.shift())); } catch {}
+      }
+    } catch { /* snapshot failure shouldn't block the save */ }
+  }
+  fs.writeFileSync(file, JSON.stringify(wf, null, 2));
 }
 
 function deleteWorkflow(id) {
   const p = path.join(WORKFLOWS_DIR, `${id}.json`);
   if (fs.existsSync(p)) fs.unlinkSync(p);
+  // Also delete versions
+  const vd = path.join(VERSIONS_DIR, id);
+  if (fs.existsSync(vd)) fs.rmSync(vd, { recursive: true, force: true });
+}
+
+function listVersions(id) {
+  const vd = path.join(VERSIONS_DIR, id);
+  if (!fs.existsSync(vd)) return [];
+  return fs.readdirSync(vd)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => {
+      const ts = f.replace(/\.json$/, '');
+      try {
+        const stat = fs.statSync(path.join(vd, f));
+        return { ts, mtime: stat.mtimeMs, size: stat.size };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.mtime - a.mtime);
+}
+
+function loadVersion(id, ts) {
+  const p = path.join(VERSIONS_DIR, id, `${ts}.json`);
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return null; }
+}
+
+// ── Credentials manager (AES-256-GCM at rest, machine-bound key) ────────────
+//
+// Why this implementation: storing API keys plain-text in config.json is the
+// #1 footgun for self-hosted automation tools. n8n encrypts credentials with
+// an encryption key (env var). We do the same but derive the key from the
+// machine identity (username + hostname + a stable salt file in ~/.nha/) so
+// the user doesn't have to set ENV vars. Tamper-detection via GCM auth tag.
+
+function _credKey() {
+  const saltFile = path.join(NHA_DIR, '.cred-salt');
+  let salt;
+  if (fs.existsSync(saltFile)) {
+    salt = fs.readFileSync(saltFile);
+  } else {
+    salt = crypto.randomBytes(32);
+    fs.mkdirSync(path.dirname(saltFile), { recursive: true });
+    fs.writeFileSync(saltFile, salt, { mode: 0o600 });
+  }
+  const identity = `${os.userInfo().username}|${os.hostname()}|nha-creds-v1`;
+  return crypto.scryptSync(identity, salt, 32);
+}
+
+function _encrypt(plaintext) {
+  const key = _credKey();
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, ciphertext]).toString('base64');
+}
+
+function _decrypt(b64) {
+  const buf = Buffer.from(b64, 'base64');
+  const iv = buf.subarray(0, 12);
+  const tag = buf.subarray(12, 28);
+  const ciphertext = buf.subarray(28);
+  const decipher = crypto.createDecipheriv('aes-256-gcm', _credKey(), iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf-8');
+}
+
+function loadCredentials() {
+  if (!fs.existsSync(CREDS_FILE)) return {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(CREDS_FILE, 'utf-8'));
+    const out = {};
+    for (const [name, entry] of Object.entries(raw)) {
+      try { out[name] = { value: _decrypt(entry.enc), updatedAt: entry.updatedAt, description: entry.description || '' }; }
+      catch { out[name] = { value: '', updatedAt: entry.updatedAt, error: 'decryption failed (machine changed?)' }; }
+    }
+    return out;
+  } catch { return {}; }
+}
+
+function saveCredential(name, value, description = '') {
+  if (!/^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(name)) throw new Error('Invalid credential name (letters, digits, _ only)');
+  const raw = fs.existsSync(CREDS_FILE) ? JSON.parse(fs.readFileSync(CREDS_FILE, 'utf-8')) : {};
+  raw[name] = { enc: _encrypt(String(value)), updatedAt: new Date().toISOString(), description };
+  if (!fs.existsSync(path.dirname(CREDS_FILE))) fs.mkdirSync(path.dirname(CREDS_FILE), { recursive: true });
+  fs.writeFileSync(CREDS_FILE, JSON.stringify(raw, null, 2), { mode: 0o600 });
+}
+
+function deleteCredential(name) {
+  if (!fs.existsSync(CREDS_FILE)) return;
+  const raw = JSON.parse(fs.readFileSync(CREDS_FILE, 'utf-8'));
+  delete raw[name];
+  fs.writeFileSync(CREDS_FILE, JSON.stringify(raw, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Interpolate ${cred.NAME} placeholders in any string value within a config.
+ * Non-strings are returned as-is. Missing creds resolve to '' and emit a warning.
+ */
+function interpolateCredentials(value, creds) {
+  if (typeof value === 'string') {
+    return value.replace(/\$\{cred\.([A-Za-z_][A-Za-z0-9_]{0,63})\}/g, (_, name) => {
+      const c = creds[name];
+      if (!c) return '';
+      return c.value || '';
+    });
+  }
+  if (Array.isArray(value)) return value.map((v) => interpolateCredentials(v, creds));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = interpolateCredentials(v, creds);
+    return out;
+  }
+  return value;
 }
 
 /** Seed example workflows on first run */
@@ -202,6 +346,22 @@ async function executeNode(node, nodeDef, ctx, config) {
       // Error handler wraps previous node execution — handled in runWorkflow
       return ctx.output || cfg.fallback || '';
     }
+    if (node.defId === 'logic_subworkflow') {
+      // Run another workflow inline. The target workflow's final node output
+      // becomes this node's output. inputMapping allows passing the parent's
+      // output (default) or a custom expression.
+      const targetId = cfg.workflowId;
+      if (!targetId) throw new Error('Subworkflow: workflowId not configured');
+      const wfPath = path.join(WORKFLOWS_DIR, `${targetId}.json`);
+      if (!fs.existsSync(wfPath)) throw new Error(`Subworkflow: target "${targetId}" not found`);
+      const subWf = JSON.parse(fs.readFileSync(wfPath, 'utf-8'));
+      const subInput = (cfg.inputMapping && cfg.inputMapping !== '{{output}}')
+        ? cfg.inputMapping.replace(/\{\{output\}\}/g, ctx.output || '')
+        : (ctx.output || '');
+      const subSteps = await runWorkflow(subWf, subInput, ctx.__config || config, { depth: (ctx.__depth ?? 0) + 1 });
+      const lastStep = subSteps.filter((s) => s.nodeId !== '__error').pop();
+      return lastStep?.output ?? '';
+    }
     return ctx.output || '';
   }
 
@@ -236,6 +396,12 @@ async function executeNode(node, nodeDef, ctx, config) {
 
   // Trigger nodes
   if (nodeDef.type === 'trigger') {
+    // For webhook triggers, prefer the live HTTP payload if present
+    if (node.defId === 'trigger_webhook' && ctx.triggerPayload !== undefined) {
+      return typeof ctx.triggerPayload === 'string'
+        ? ctx.triggerPayload
+        : JSON.stringify(ctx.triggerPayload);
+    }
     return ctx.output || cfg.input || '';
   }
 
@@ -245,10 +411,31 @@ async function executeNode(node, nodeDef, ctx, config) {
 /**
  * Run a workflow from start to finish.
  * Returns array of { nodeId, output, error? } step results.
+ *
+ * @param {object} wf - workflow definition
+ * @param {string} initialInput - text input piped into start node
+ * @param {object} config - NHA config
+ * @param {object} [opts] - { depth: number, triggerPayload: any }
+ *   depth: protects against subworkflow recursion (max 5).
+ *   triggerPayload: when the workflow was started by a webhook, this is the
+ *     raw request body, injected into ctx.trigger for downstream nodes.
  */
-async function runWorkflow(wf, initialInput, config) {
+async function runWorkflow(wf, initialInput, config, opts = {}) {
+  const depth = opts.depth ?? 0;
+  if (depth > 5) return [{ nodeId: '__error', nodeLabel: 'Error', nodeIcon: '❌', output: 'Subworkflow recursion depth limit (5) exceeded.' }];
+
+  // Resolve credentials placeholders ${cred.NAME} in every node config BEFORE
+  // executing. This way every executeNode call receives plain values — the
+  // node implementation doesn't need to know about the credentials system.
+  const creds = loadCredentials();
+  const interpolatedNodes = wf.nodes.map((n) => ({
+    ...n,
+    config: interpolateCredentials(n.config || {}, creds),
+  }));
+  const interpolatedWf = { ...wf, nodes: interpolatedNodes };
+
   const steps = [];
-  const nodeMap = Object.fromEntries(wf.nodes.map((n) => [n.id, n]));
+  const nodeMap = Object.fromEntries(interpolatedWf.nodes.map((n) => [n.id, n]));
   const defMap = Object.fromEntries((wf.nodeDefs || []).map((d) => [d.id, d]));
 
   // Build adjacency: from → [{to, fromPort}]
@@ -270,7 +457,14 @@ async function runWorkflow(wf, initialInput, config) {
   if (startCandidates.length === 0) return [{ nodeId: '__error', nodeLabel: 'Error', nodeIcon: '❌', output: 'No start node found.' }];
 
   // BFS execution with branching support
-  const queue = startCandidates.map((n) => ({ nodeId: n.id, ctx: { output: initialInput || '', input: initialInput || '' } }));
+  const baseCtx = {
+    output: initialInput || '',
+    input: initialInput || '',
+    triggerPayload: opts.triggerPayload,
+    __depth: depth,
+    __config: config,
+  };
+  const queue = startCandidates.map((n) => ({ nodeId: n.id, ctx: { ...baseCtx } }));
   const visited = new Set();
 
   while (queue.length > 0) {
@@ -442,4 +636,94 @@ export function register(router) {
       sendError(res, 500, e.message);
     }
   });
+
+  // ── Versioning ───────────────────────────────────────────────────────────
+  router.get('/api/workflows/:id/versions', async (req, res) => {
+    try { sendJSON(res, 200, { versions: listVersions(req.params?.id) }); }
+    catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.get('/api/workflows/:id/versions/:ts', async (req, res) => {
+    try {
+      const wf = loadVersion(req.params?.id, req.params?.ts);
+      if (!wf) return sendError(res, 404, 'Version not found');
+      sendJSON(res, 200, { workflow: wf });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/workflows/:id/restore/:ts', async (req, res) => {
+    try {
+      const wf = loadVersion(req.params?.id, req.params?.ts);
+      if (!wf) return sendError(res, 404, 'Version not found');
+      saveWorkflow(wf);  // creates a new snapshot of current state automatically
+      sendJSON(res, 200, { ok: true, workflow: wf });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  // ── Credentials manager ─────────────────────────────────────────────────
+  router.get('/api/credentials', async (_req, res) => {
+    try {
+      const creds = loadCredentials();
+      // NEVER return raw values — only names + metadata
+      const list = Object.entries(creds).map(([name, c]) => ({
+        name, updatedAt: c.updatedAt, description: c.description, hasError: !!c.error,
+      }));
+      sendJSON(res, 200, { credentials: list });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/credentials', async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      if (!body.name || !body.value) return sendError(res, 400, 'name and value required');
+      saveCredential(body.name, body.value, body.description || '');
+      sendJSON(res, 200, { ok: true });
+    } catch (e) { sendError(res, 400, e.message); }
+  });
+
+  router.delete('/api/credentials/:name', async (req, res) => {
+    try {
+      deleteCredential(req.params?.name);
+      sendJSON(res, 200, { ok: true });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  // ── Webhook triggers ─────────────────────────────────────────────────────
+  //
+  // ANY method to /api/webhooks/<slug> triggers a workflow whose start node
+  // is a trigger_webhook with config.slug matching. The HTTP body is injected
+  // as triggerPayload — text/plain stays as string, application/json gets
+  // parsed. We respond with the last node's output (or 200 OK if no output).
+  const _handleWebhook = async (req, res) => {
+    try {
+      const slug = req.params?.slug;
+      if (!slug) return sendError(res, 400, 'webhook slug required');
+      const all = listWorkflows();
+      const wf = all.find((w) => (w.nodes || []).some((n) =>
+        n.defId === 'trigger_webhook' && (n.config?.slug === slug || n.config?.path === slug),
+      ));
+      if (!wf) return sendError(res, 404, `No workflow registered for webhook /${slug}`);
+      if (wf.enabled === false) return sendError(res, 403, 'Workflow is disabled');
+
+      // Parse body — try JSON, fall back to text
+      let payload = '';
+      try { payload = await parseBody(req); }
+      catch { payload = ''; }
+
+      const config = loadConfig();
+      const steps = await runWorkflow(wf, typeof payload === 'string' ? payload : JSON.stringify(payload), config, { triggerPayload: payload });
+      const last = steps.filter((s) => s.nodeId !== '__error').pop();
+      const output = last?.output ?? '';
+      // If the output looks like JSON, return it as JSON; otherwise as text
+      try { sendJSON(res, 200, JSON.parse(output)); }
+      catch {
+        res.writeHead(200, { 'Content-Type': 'text/plain', 'Access-Control-Allow-Origin': '*' });
+        res.end(String(output));
+      }
+    } catch (e) { sendError(res, 500, e.message); }
+  };
+  router.post('/api/webhooks/:slug',   _handleWebhook);
+  router.get( '/api/webhooks/:slug',   _handleWebhook);
+  router.put( '/api/webhooks/:slug',   _handleWebhook);
+  router.delete('/api/webhooks/:slug', _handleWebhook);
 }

package/src/services/tool-executor.mjs

@@ -296,7 +296,7 @@ TOOLS:
 
 41. slack_send(channel: string, text: string, threadTs?: string)
     Send a message to a Slack channel. ALWAYS confirm before sending.
-    If `threadTs` is provided, post as a thread reply instead of a top-level message.
+    If threadTs is provided, post as a thread reply instead of a top-level message.
 
 41b. slack_search(query: string, count?: number)
      Full-text search messages across the whole Slack workspace. Returns the most
@@ -305,18 +305,18 @@ TOOLS:
      su X", "did anyone post about the release", etc.
 
 41c. slack_dm(user: string, text?: string)
-     Open or send a direct message to a user. `user` accepts Slack user ID (Uxxx),
-     username, real name, or email — the tool resolves them automatically.
-     If `text` is provided, the message is sent immediately; otherwise the DM
-     channel is just opened.
+     Open or send a direct message to a user. The user parameter accepts a Slack
+     user ID (Uxxx), username, real name, or email — the tool resolves them
+     automatically. If text is provided, the message is sent immediately; otherwise
+     the DM channel is just opened.
 
 41d. slack_thread(channel: string, ts: string)
-     List all replies in a thread. `ts` is the parent message timestamp (returned
+     List all replies in a thread. ts is the parent message timestamp (returned
      by slack_messages or slack_search). Use this before posting a contextual
      reply with slack_send + threadTs.
 
 41e. slack_react(channel: string, ts: string, emoji: string)
-     Add an emoji reaction to a message. `emoji` is the name without colons
+     Add an emoji reaction to a message. emoji is the name without colons
      (e.g. "thumbsup", "rocket", "white_check_mark"). Confirm before reacting on
      someone else's message.