nothumanallowed 13.5.200 → 14.0.1

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

package/src/server/index.mjs

@@ -0,0 +1,299 @@
+/**
+ * NHA UI Server — autonomous backend for the React UI.
+ *
+ * Zero extra npm dependencies — Node.js 22 http module only.
+ * Serves the React build (ui-dist/) statically + all /api/* routes.
+ *
+ * Architecture:
+ *   server/
+ *   ├── index.mjs          ← this file (HTTP server + router)
+ *   ├── routes/            ← one file per domain
+ *   │   ├── chat.mjs
+ *   │   ├── studio.mjs
+ *   │   ├── email.mjs
+ *   │   ├── calendar.mjs
+ *   │   ├── tasks.mjs
+ *   │   ├── config.mjs
+ *   │   ├── agents.mjs
+ *   │   ├── integrations.mjs
+ *   │   ├── drive.mjs
+ *   │   ├── collab.mjs
+ *   │   └── google-auth.mjs
+ *   └── ws.mjs             ← WebSocket handler
+ */
+
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+
+// ── Paths ────────────────────────────────────────────────────────────────────
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Fallback to local dist/ if run standalone (e.g. during development)
+const _cliDist   = path.resolve(__dirname, '../ui-dist');
+const _localDist = path.resolve(__dirname, '../dist');
+const UI_DIST = fs.existsSync(path.join(_cliDist, 'index.html')) ? _cliDist : _localDist;
+
+// ── MIME types ───────────────────────────────────────────────────────────────
+
+const MIME = {
+  '.html':  'text/html; charset=utf-8',
+  '.js':    'application/javascript; charset=utf-8',
+  '.css':   'text/css; charset=utf-8',
+  '.svg':   'image/svg+xml',
+  '.png':   'image/png',
+  '.ico':   'image/x-icon',
+  '.woff2': 'font/woff2',
+  '.woff':  'font/woff',
+  '.ttf':   'font/ttf',
+  '.json':  'application/json',
+  '.map':   'application/json',
+  '.jpg':   'image/jpeg',
+  '.jpeg':  'image/jpeg',
+  '.webp':  'image/webp',
+};
+
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+export function sendJSON(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+    'Cache-Control': 'no-cache',
+  });
+  res.end(body);
+}
+
+export function sendError(res, status, message) {
+  sendJSON(res, status, { error: message });
+}
+
+export function parseBody(req, maxBytes = 10_485_760) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', chunk => {
+      size += chunk.length;
+      if (size > maxBytes) { reject(new Error('Body too large')); req.destroy(); return; }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        const raw = Buffer.concat(chunks).toString('utf-8');
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (e) { reject(e); }
+    });
+    req.on('error', reject);
+  });
+}
+
+export function sendSSE(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+  });
+  return {
+    send: (data) => res.write(`data: ${JSON.stringify(data)}\n\n`),
+    end: () => { res.write('data: [DONE]\n\n'); res.end(); },
+  };
+}
+
+function serveStatic(res, filePath) {
+  try {
+    const data = fs.readFileSync(filePath);
+    const ext = path.extname(filePath);
+    const ct = MIME[ext] || 'application/octet-stream';
+    const cache = ext === '.html' ? 'no-store' : 'public, max-age=31536000, immutable';
+    res.writeHead(200, { 'Content-Type': ct, 'Cache-Control': cache });
+    res.end(data);
+    return true;
+  } catch { return false; }
+}
+
+function logRequest(method, url, status, ms) {
+  const G = '\x1b[0;32m', D = '\x1b[2m', NC = '\x1b[0m', R = '\x1b[0;31m';
+  const color = status < 400 ? G : R;
+  console.log(`  ${D}${new Date().toISOString().slice(11,19)}${NC}  ${color}${status}${NC}  ${method.padEnd(6)} ${url}  ${D}${ms}ms${NC}`);
+}
+
+function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${cmd} ${url}`, () => {});
+}
+
+// ── Route registry ───────────────────────────────────────────────────────────
+
+// Each route module exports: { register(router) }
+// router = { get, post, put, delete, patch } — simple prefix matcher
+
+class Router {
+  constructor() { this._routes = []; }
+
+  _add(method, pattern, handler) {
+    this._routes.push({ method: method.toUpperCase(), pattern, handler });
+  }
+  get(p, h)    { this._add('GET', p, h); }
+  post(p, h)   { this._add('POST', p, h); }
+  put(p, h)    { this._add('PUT', p, h); }
+  patch(p, h)  { this._add('PATCH', p, h); }
+  delete(p, h) { this._add('DELETE', p, h); }
+
+  match(method, pathname) {
+    for (const r of this._routes) {
+      if (r.method !== method) continue;
+      if (typeof r.pattern === 'string') {
+        if (r.pattern === pathname) return { handler: r.handler, params: {} };
+      } else if (r.pattern instanceof RegExp) {
+        const m = pathname.match(r.pattern);
+        if (m) return { handler: r.handler, params: m.groups || {}, match: m };
+      }
+    }
+    return null;
+  }
+
+  // prefix match — used for routes that need to match /api/foo/*
+  matchPrefix(method, pathname) {
+    for (const r of this._routes) {
+      if (r.method !== method) continue;
+      if (typeof r.pattern === 'string' && pathname.startsWith(r.pattern + '/')) {
+        return { handler: r.handler, params: {} };
+      }
+    }
+    return null;
+  }
+}
+
+async function buildRouter() {
+  const router = new Router();
+  const mods = await Promise.all([
+    import('./routes/config.mjs'),
+    import('./routes/chat.mjs'),
+    import('./routes/studio.mjs'),
+    import('./routes/webcraft.mjs'),
+    import('./routes/email.mjs'),
+    import('./routes/calendar.mjs'),
+    import('./routes/tasks.mjs'),
+    import('./routes/agents.mjs'),
+    import('./routes/drive.mjs'),
+    import('./routes/integrations.mjs'),
+    import('./routes/collab.mjs'),
+    import('./routes/google-auth.mjs'),
+  ]);
+  for (const mod of mods) mod.register(router);
+  return router;
+}
+
+// ── Main request handler ─────────────────────────────────────────────────────
+
+let _router = null; // initialized in startServer()
+
+async function handleRequest(req, res) {
+  const router = _router;
+  const start = Date.now();
+  const url = new URL(req.url, `http://localhost`);
+  const { pathname } = url;
+  const method = req.method;
+
+  // CORS preflight
+  if (method === 'OPTIONS') {
+    res.writeHead(204, {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+    });
+    res.end();
+    return;
+  }
+
+  try {
+    // ── API routes ──────────────────────────────────────────────────────
+    if (pathname.startsWith('/api/')) {
+      const match = router.match(method, pathname);
+      if (match) {
+        req.params = match.params;
+        req.query = Object.fromEntries(url.searchParams);
+        await match.handler(req, res);
+        logRequest(method, pathname, res.statusCode || 200, Date.now() - start);
+        return;
+      }
+      // prefix-based routes (for dynamic segments like /api/agents/:id)
+      // handled inside route modules via req.params injected above
+      sendError(res, 404, `Unknown API route: ${method} ${pathname}`);
+      logRequest(method, pathname, 404, Date.now() - start);
+      return;
+    }
+
+    // ── Suppress browser probes ─────────────────────────────────────────
+    if (pathname.startsWith('/.well-known')) {
+      res.writeHead(204); res.end(); return;
+    }
+
+    // ── Serve React build (static files) ───────────────────────────────
+    if (method === 'GET') {
+      if (fs.existsSync(path.join(UI_DIST, 'index.html'))) {
+        const file = pathname === '/' ? 'index.html' : pathname.slice(1);
+        if (serveStatic(res, path.join(UI_DIST, file))) {
+          logRequest(method, pathname, 200, Date.now() - start);
+          return;
+        }
+        // SPA fallback
+        serveStatic(res, path.join(UI_DIST, 'index.html'));
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+      // No build yet
+      res.writeHead(503, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(`<!DOCTYPE html><html><body style="font-family:monospace;padding:2rem;background:#0a0a0a;color:#e5e5e5">
+<h2 style="color:#22c55e">NHA UI — build not found</h2>
+<p>Run: <code style="background:#1a1a1a;padding:2px 8px;border-radius:4px">cd packages/nha-ui &amp;&amp; pnpm build</code></p>
+</body></html>`);
+      logRequest(method, pathname, 503, Date.now() - start);
+      return;
+    }
+
+    res.writeHead(404); res.end();
+  } catch (e) {
+    console.error('[server] Error handling request:', e);
+    if (!res.headersSent) sendError(res, 500, e.message);
+    logRequest(method, pathname, 500, Date.now() - start);
+  }
+}
+
+// ── Start ────────────────────────────────────────────────────────────────────
+
+export async function startServer({ port = 3847, host = '127.0.0.1', noBrowser = false } = {}) {
+  _router = await buildRouter();
+  const { setupWebSocket } = await import('./ws.mjs');
+
+  const server = http.createServer(handleRequest);
+  setupWebSocket(server);
+
+  await new Promise((resolve, reject) => {
+    server.listen(port, host, (err) => err ? reject(err) : resolve());
+  });
+
+  const G = '\x1b[0;32m', NC = '\x1b[0m', D = '\x1b[2m', BOLD = '\x1b[1m';
+  const { VERSION } = await import('../constants.mjs');
+  console.log(`\n  ${BOLD}${G}NHA${NC} ${D}v${VERSION}${NC}`);
+  console.log(`  ${G}✓${NC} Server running on ${G}http://${host}:${port}${NC}`);
+  console.log(`  ${D}Press Ctrl+C to stop${NC}\n`);
+
+  // Telemetry ping — fire and forget
+  fetch('https://nothumanallowed.com/api/v1/telemetry/ping', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ platform: 'nha-ui', version: VERSION }),
+  }).catch(() => {});
+
+  if (!noBrowser) openBrowser(`http://localhost:${port}`);
+
+  return server;
+}

package/src/server/routes/agents.mjs

@@ -0,0 +1,109 @@
+/**
+ * Agents routes — /api/agents CRUD + /api/ask/stream
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { sendJSON, sendError, parseBody } from '../index.mjs';
+import { loadConfig } from '../../config.mjs';
+import { AGENTS_DIR, NHA_DIR } from '../../constants.mjs';
+import { callLLMStream, parseAgentFile } from '../../services/llm.mjs';
+
+function loadAgentCards() {
+  if (!fs.existsSync(AGENTS_DIR)) return [];
+  return fs.readdirSync(AGENTS_DIR)
+    .filter(f => f.endsWith('.mjs'))
+    .map(f => {
+      try {
+        const src = fs.readFileSync(path.join(AGENTS_DIR, f), 'utf-8');
+        return parseAgentFile(src, f.replace('.mjs',''));
+      } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+export function register(router) {
+  router.get('/api/agents', (_req, res) => {
+    sendJSON(res, 200, { agents: loadAgentCards() });
+  });
+
+  router.post('/api/agents', async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      if (!body.name || !body.systemPrompt) return sendError(res, 400, 'name and systemPrompt required');
+      fs.mkdirSync(AGENTS_DIR, { recursive: true });
+      const slug = body.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+      const file = path.join(AGENTS_DIR, `${slug}.mjs`);
+      if (fs.existsSync(file)) return sendError(res, 409, 'Agent already exists');
+      const content = `// Agent: ${body.name}\nexport const agent = {\n  name: "${body.name}",\n  icon: "${body.icon || '🤖'}",\n  description: "${(body.description || '').replace(/"/g,'\\\"')}",\n  systemPrompt: \`${body.systemPrompt.replace(/`/g,'\\`')}\`,\n};\nexport default agent;\n`;
+      fs.writeFileSync(file, content, 'utf-8');
+      sendJSON(res, 201, { ok: true, slug });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  const AGENT_RE = /^\/api\/agents\/([a-z0-9-]+)$/;
+
+  router.get(AGENT_RE, (req, res) => {
+    const slug = req.url.match(AGENT_RE)?.[1];
+    const file = path.join(AGENTS_DIR, `${slug}.mjs`);
+    if (!fs.existsSync(file)) return sendError(res, 404, 'Agent not found');
+    try {
+      const src = fs.readFileSync(file, 'utf-8');
+      sendJSON(res, 200, { agent: parseAgentFile(src, slug) });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.put(AGENT_RE, async (req, res) => {
+    try {
+      const slug = req.url.match(AGENT_RE)?.[1];
+      const file = path.join(AGENTS_DIR, `${slug}.mjs`);
+      if (!fs.existsSync(file)) return sendError(res, 404, 'Agent not found');
+      const body = await parseBody(req);
+      const content = `// Agent: ${body.name || slug}\nexport const agent = {\n  name: "${body.name || slug}",\n  icon: "${body.icon || '🤖'}",\n  description: "${(body.description || '').replace(/"/g,'\\\"')}",\n  systemPrompt: \`${(body.systemPrompt || '').replace(/`/g,'\\`')}\`,\n};\nexport default agent;\n`;
+      fs.writeFileSync(file, content, 'utf-8');
+      sendJSON(res, 200, { ok: true });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.delete(AGENT_RE, (req, res) => {
+    const slug = req.url.match(AGENT_RE)?.[1];
+    const file = path.join(AGENTS_DIR, `${slug}.mjs`);
+    if (!fs.existsSync(file)) return sendError(res, 404, 'Agent not found');
+    fs.unlinkSync(file);
+    sendJSON(res, 200, { ok: true });
+  });
+
+  // POST /api/ask/stream — single agent streaming ask
+  router.post('/api/ask/stream', async (req, res) => {
+    const body = await parseBody(req);
+    if (!body.message) return sendError(res, 400, 'message required');
+    const config = loadConfig();
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    });
+    const sse = (ev, data) => res.write(`event: ${ev}\ndata: ${JSON.stringify(data)}\n\n`);
+
+    try {
+      const agentSlug = body.agent?.toLowerCase();
+      let sysProm = 'You are a helpful AI assistant.';
+      if (agentSlug) {
+        const af = path.join(AGENTS_DIR, `${agentSlug}.mjs`);
+        if (fs.existsSync(af)) {
+          const parsed = parseAgentFile(fs.readFileSync(af, 'utf-8'), agentSlug);
+          if (parsed.systemPrompt) sysProm = parsed.systemPrompt;
+        }
+      }
+      await callLLMStream(config, sysProm, body.message, (tok) => sse('token', { content: tok }));
+      sse('done', {});
+      res.write('data: [DONE]\n\n');
+      res.end();
+    } catch (e) {
+      sse('error', { message: e.message });
+      res.end();
+    }
+  });
+}

package/src/server/routes/calendar.mjs

@@ -0,0 +1,115 @@
+/**
+ * Calendar + Tasks + Plan routes
+ */
+
+import { sendJSON, sendError, parseBody } from '../index.mjs';
+import { loadConfig } from '../../config.mjs';
+import { getTodayEvents, getUpcomingEvents, createEvent, updateEvent, deleteEvent, getEventsForDate } from '../../services/mail-router.mjs';
+import { getTasks, addTask, completeTask, getDayStats } from '../../services/task-store.mjs';
+import { runPlanningPipeline } from '../../services/ops-pipeline.mjs';
+import { NHA_DIR } from '../../constants.mjs';
+import fs from 'fs';
+import path from 'path';
+
+export function register(router) {
+  // ── Calendar ──────────────────────────────────────────────────────────
+
+  router.get('/api/calendar', async (req, res) => {
+    try {
+      const config = loadConfig();
+      const url = new URL(req.url, 'http://localhost');
+      const date = url.searchParams.get('date');
+      const events = date ? await getEventsForDate(config, date) : await getTodayEvents(config);
+      sendJSON(res, 200, { events });
+    } catch (e) {
+      const msg = e.message || '';
+      if (msg.includes('No mail provider') || msg.includes('not authenticated') || msg.includes('No Google') || msg.includes('token')) {
+        return sendJSON(res, 200, { events: [], authRequired: true, error: msg });
+      }
+      sendError(res, 500, msg);
+    }
+  });
+
+  router.get('/api/calendar/upcoming', async (req, res) => {
+    try {
+      const config = loadConfig();
+      const url = new URL(req.url, 'http://localhost');
+      const hours = parseInt(url.searchParams.get('hours') || '24', 10);
+      const events = await getUpcomingEvents(config, hours);
+      sendJSON(res, 200, { events });
+    } catch (e) {
+      const msg = e.message || '';
+      if (msg.includes('No mail provider') || msg.includes('not authenticated') || msg.includes('token')) {
+        return sendJSON(res, 200, { events: [], authRequired: true });
+      }
+      sendError(res, 500, msg);
+    }
+  });
+
+  router.post('/api/calendar', async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      const config = loadConfig();
+      if (body.action === 'update' && body.id) {
+        const updated = await updateEvent(config, body.id, body);
+        return sendJSON(res, 200, { event: updated });
+      }
+      if (body.action === 'delete' && body.id) {
+        await deleteEvent(config, body.id);
+        return sendJSON(res, 200, { ok: true });
+      }
+      const event = await createEvent(config, body);
+      sendJSON(res, 201, { event });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  // ── Tasks ─────────────────────────────────────────────────────────────
+
+  router.get('/api/tasks', async (req, res) => {
+    try {
+      const url = new URL(req.url, 'http://localhost');
+      const date = url.searchParams.get('date');
+      const tasks = getTasks(date);
+      sendJSON(res, 200, { tasks, stats: getDayStats(date) });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/tasks', async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      if (body.action === 'complete') {
+        completeTask(body.id);
+        return sendJSON(res, 200, { ok: true });
+      }
+      if (body.action === 'clear') {
+        const { clearTasks } = await import('../../services/task-store.mjs');
+        clearTasks(body.date);
+        return sendJSON(res, 200, { ok: true });
+      }
+      const task = addTask(body);
+      sendJSON(res, 201, { task });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  // ── Daily Plan ────────────────────────────────────────────────────────
+
+  router.get('/api/plan', async (_req, res) => {
+    try {
+      const dateStr = new Date().toISOString().split('T')[0];
+      const planFile = path.join(NHA_DIR, 'ops', 'plans', `${dateStr}.json`);
+      if (fs.existsSync(planFile)) {
+        sendJSON(res, 200, JSON.parse(fs.readFileSync(planFile, 'utf-8')));
+      } else {
+        sendJSON(res, 200, { plan: null });
+      }
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  router.post('/api/plan/refresh', async (_req, res) => {
+    try {
+      const config = loadConfig();
+      const plan = await runPlanningPipeline(config);
+      sendJSON(res, 200, { plan });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+}