nothumanallowed 14.4.12 → 14.4.14

package/package.json

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

package/src/server/routes/webcraft.mjs

@@ -381,23 +381,95 @@ const SkillStore = {
     if (fs.existsSync(abs)) fs.unlinkSync(abs);
   },
 
-  /** Ensure memory.md, skills.md, and provider.md always exist for a project. */
+  /** Ensure memory.md, skills.md, and provider.md always exist with useful content. */
   ensureDefaults(projectName, config) {
     const dir = ensureDir(this.dir(projectName));
     const provider = config?.llm?.provider || 'nha';
     const model = config?.llm?.model || '';
+    const projectDir = path.join(NHA_DIR, 'webcraft', projectName);
+
+    // Scan project files for auto-generating context
+    let fileList = '';
+    try {
+      const files = fs.readdirSync(projectDir, { recursive: true })
+        .filter((f) => !String(f).includes('node_modules') && !String(f).startsWith('.nha-') && !String(f).startsWith('.'));
+      fileList = files.slice(0, 30).join(', ');
+    } catch {}
+
+    const needsWrite = (filePath, minLen = 150) => {
+      if (!fs.existsSync(filePath)) return true;
+      return fs.readFileSync(filePath, 'utf-8').length < minLen;
+    };
 
     const memFile = path.join(dir, 'memory.md');
-    if (!fs.existsSync(memFile)) {
-      fs.writeFileSync(memFile, `# ${projectName} — Project Memory\n\n_Architectural decisions, preferences, and notes._\n`, 'utf-8');
+    if (needsWrite(memFile)) {
+      fs.writeFileSync(memFile, `# ${projectName} — Project Memory
+
+## Project Files
+${fileList || '_No files generated yet_'}
+
+## Architecture
+- Express.js server with middleware stack
+- Vanilla HTML/CSS/JS frontend
+- JSON file storage (no external DB)
+
+## Development Notes
+_The AI agent updates this file as you build. Ask it to add features one by one._
+_Example: "Add user authentication" or "Add a contact form"_
+
+## Completed Features
+_None yet — start building!_
+`, 'utf-8');
     }
+
     const skillsFile = path.join(dir, 'skills.md');
-    if (!fs.existsSync(skillsFile)) {
-      fs.writeFileSync(skillsFile, `# ${projectName} — Skills\n\n_Coding patterns, best practices, and conventions for this project._\n`, 'utf-8');
+    if (needsWrite(skillsFile)) {
+      fs.writeFileSync(skillsFile, `# ${projectName} — Skills & Conventions
+
+## Code Style
+- Modern ES6+: const/let, arrow functions, async/await, template literals
+- Express routes: router.get/post/put/delete with error handling
+- CSS: custom properties (--primary, --bg), mobile-first, flexbox/grid
+- HTML: semantic tags, accessible (aria-labels, focus styles)
+
+## File Structure
+- server.js — main entry, middleware, routes
+- public/ — static HTML/CSS/JS
+- routes/ — Express route handlers
+- middleware/ — auth, validation, error handling
+- models/ — data models with JSON storage
+
+## Patterns
+- Always validate input on server side
+- Use try/catch for async operations
+- Return proper HTTP status codes (200, 201, 400, 401, 404, 500)
+- CSS variables for theming, transitions for hover states
+`, 'utf-8');
     }
+
     const providerFile = path.join(dir, `${provider}.md`);
-    if (!fs.existsSync(providerFile)) {
-      fs.writeFileSync(providerFile, `# ${provider.toUpperCase()} — ${model || 'Default'}\n\n_Model-specific notes, prompt tips, and configuration._\n`, 'utf-8');
+    if (needsWrite(providerFile)) {
+      fs.writeFileSync(providerFile, `# ${provider.toUpperCase()} — ${model || 'Default'}
+
+## Project: ${projectName}
+
+## Instructions for Code Generation
+- Generate COMPLETE files — never truncate
+- Use external CSS/JS via link/script tags
+- Every function must be fully implemented — no TODOs or placeholders
+- Handle errors gracefully with try/catch
+- Mobile-first responsive design
+- Dark mode support via CSS custom properties
+
+## Available Tools
+read, edit, write, rename, delete, check, lint, search, list, run, sandbox, diff
+
+## Workflow
+1. Read files before editing
+2. Make surgical edits (not full rewrites unless needed)
+3. Check/lint after modifications
+4. Restart sandbox to verify
+`, 'utf-8');
     }
   },
 

package/src/server/ws.mjs

@@ -8,7 +8,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { execFile } from 'child_process';
 import { NHA_DIR } from '../constants.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -55,63 +55,103 @@ export function setupWebSocket(server) {
   });
 
   wssTerminal.on('connection', (ws, req) => {
-    // Parse project from query: /api/terminal?cwd=ProjectName
     const url = new URL(req.url || '', 'http://localhost');
     const cwdParam = url.searchParams.get('cwd') || '';
     let cwd;
     if (cwdParam && !cwdParam.includes('/') && !cwdParam.includes('\\')) {
-      // Project name → resolve to webcraft dir
       cwd = path.join(NHA_DIR, 'webcraft', cwdParam);
     } else if (cwdParam) {
       cwd = cwdParam;
     } else {
       cwd = path.join(NHA_DIR, 'webcraft');
     }
-    // Security: ensure cwd is under NHA_DIR or home
     const home = os.homedir();
     if (!cwd.startsWith(NHA_DIR) && !cwd.startsWith(home)) cwd = home;
     if (!fs.existsSync(cwd)) cwd = home;
 
-    const shell = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/sh');
-    const shellArgs = process.platform === 'win32' ? [] : ['-i']; // interactive
+    // Command runner mode — user sends commands, we exec them and return output
+    let currentCwd = cwd;
+    let cmdBuffer = '';
 
-    const proc = spawn(shell, shellArgs, {
-      cwd,
-      env: { ...process.env, TERM: 'xterm-256color', LANG: 'en_US.UTF-8' },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    // Shell stdout → WS
-    proc.stdout.on('data', (data) => {
-      if (ws.readyState === 1) ws.send(data);
-    });
+    const send = (text) => { if (ws.readyState === 1) ws.send(text); };
 
-    // Shell stderr → WS
-    proc.stderr.on('data', (data) => {
-      if (ws.readyState === 1) ws.send(data);
-    });
+    send(`\x1b[32mNHA Terminal\x1b[0m\r\n`);
+    send(`\x1b[90m${currentCwd}\x1b[0m\r\n`);
+    send(`\x1b[36m$ \x1b[0m`);
 
-    // WS → Shell stdin
     ws.on('message', (data) => {
-      if (proc.stdin.writable) proc.stdin.write(data);
-    });
-
-    // Cleanup
-    proc.on('exit', () => {
-      if (ws.readyState === 1) ws.send('\r\n[shell exited]\r\n');
-      ws.close();
+      const char = data.toString();
+
+      // Handle special keys
+      if (char === '\r' || char === '\n') {
+        send('\r\n');
+        const cmd = cmdBuffer.trim();
+        cmdBuffer = '';
+
+        if (!cmd) {
+          send(`\x1b[36m$ \x1b[0m`);
+          return;
+        }
+
+        // Built-in: cd
+        if (cmd.startsWith('cd ')) {
+          const target = cmd.slice(3).trim().replace('~', home);
+          const newCwd = path.resolve(currentCwd, target);
+          if (fs.existsSync(newCwd) && fs.statSync(newCwd).isDirectory()) {
+            currentCwd = newCwd;
+            send(`\x1b[90m${currentCwd}\x1b[0m\r\n`);
+          } else {
+            send(`\x1b[31mcd: no such directory: ${target}\x1b[0m\r\n`);
+          }
+          send(`\x1b[36m$ \x1b[0m`);
+          return;
+        }
+
+        // Built-in: clear
+        if (cmd === 'clear' || cmd === 'cls') {
+          send('\x1b[2J\x1b[H');
+          send(`\x1b[90m${currentCwd}\x1b[0m\r\n`);
+          send(`\x1b[36m$ \x1b[0m`);
+          return;
+        }
+
+        // Execute command — fully isolated from parent process stdio
+        const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+        const shellArg = process.platform === 'win32' ? '/c' : '-c';
+        const child = execFile(shell, [shellArg, cmd], {
+          cwd: currentCwd,
+          timeout: 30_000,
+          env: { ...process.env, TERM: 'dumb', NODE_ENV: 'development' },
+          maxBuffer: 1024 * 1024,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }, (err, stdout, stderr) => {
+          if (stdout) send(stdout.replace(/\n/g, '\r\n'));
+          if (stderr) send(`\x1b[31m${stderr.replace(/\n/g, '\r\n')}\x1b[0m`);
+          if (err && err.killed) send(`\x1b[31m[timeout]\x1b[0m\r\n`);
+          else if (err && !stdout && !stderr) send(`\x1b[31m${err.message}\x1b[0m\r\n`);
+          send(`\x1b[90m${currentCwd}\x1b[0m\r\n`);
+          send(`\x1b[36m$ \x1b[0m`);
+        });
+      } else if (char === '\x7f' || char === '\b') {
+        // Backspace
+        if (cmdBuffer.length > 0) {
+          cmdBuffer = cmdBuffer.slice(0, -1);
+          send('\b \b');
+        }
+      } else if (char === '\x03') {
+        // Ctrl+C
+        cmdBuffer = '';
+        send('^C\r\n');
+        send(`\x1b[36m$ \x1b[0m`);
+      } else if (char.charCodeAt(0) >= 32) {
+        // Normal character
+        cmdBuffer += char;
+        send(char);
+      }
     });
 
-    ws.on('close', () => {
-      try { proc.kill(); } catch {}
-    });
-
-    ws.on('error', () => {
-      try { proc.kill(); } catch {}
-    });
-
-    // Welcome message
-    ws.send(`\x1b[32mNHA Terminal\x1b[0m — ${cwd}\r\n`);
+    ws.on('close', () => {});
+    ws.on('error', () => {});
   });
 }