attesso 0.4.1 → 0.6.0

package/src/ui/server.mjs

@@ -0,0 +1,379 @@
+// Local Bounds control surface. One loopback process, one per-run token, one
+// ledger. The page is static; all state comes from the same core functions the
+// CLI uses. No hosted code and no second policy implementation.
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { gzipSync } from 'node:zlib';
+import { connect as connectAgent, setModeAll, status as agentStatus } from '../connect.mjs';
+import { validatePathsConfig } from '../fs-paths.mjs';
+import { isInitialised, paths, readEntries } from '../store.mjs';
+import { Catalog, validateTimeZone } from './catalog.mjs';
+import { usageForDay } from '../usage.mjs';
+import { days as queryDays, flow as queryFlow, page as queryPage, parseCursor, parseDay, parseLimit, summary as querySummary } from './query.mjs';
+import { LedgerTail } from './live.mjs';
+
+const UI_ROOT = dirname(fileURLToPath(import.meta.url));
+const STATIC_ROOT = join(UI_ROOT, 'static');
+const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8' };
+const MAX_BODY = 512_000;
+
+const localDay = (date) => {
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+};
+const localTime = (date) => {
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+};
+
+function rowFor(entry) {
+  const date = new Date(entry.at);
+  return [
+    entry.seq,
+    localTime(date),
+    entry.subject ?? 'unknown',
+    entry.capability ?? 'unknown',
+    entry.decision ?? 'UNKNOWN',
+    entry.code ?? '',
+    entry.task ?? 'unknown',
+  ];
+}
+
+function callsPayload(dir) {
+  if (!isInitialised(dir)) return { days: {}, head: 0 };
+  const days = {};
+  let head = 0;
+  for (const entry of readEntries(dir)) {
+    head = Math.max(head, entry.seq);
+    if (entry.action === 'llm.session') continue;
+    const day = localDay(new Date(entry.at));
+    if (!days[day]) days[day] = [];
+    days[day].push(rowFor(entry));
+  }
+  return { days, head };
+}
+
+const readJson = (file, fallback) => {
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return fallback; }
+};
+const writeJson = (file, value) => {
+  const temp = `${file}.${process.pid}.${randomBytes(5).toString('hex')}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temp, file);
+};
+
+function send(req, res, status, type, body) {
+  const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body);
+  const headers = { 'content-type': type, 'cache-control': 'no-store' };
+  if (buffer.length > 1024 && String(req.headers['accept-encoding'] ?? '').includes('gzip')) {
+    const compressed = gzipSync(buffer, { level: 6 });
+    headers['content-encoding'] = 'gzip';
+    headers.vary = 'accept-encoding';
+    res.writeHead(status, headers);
+    return res.end(compressed);
+  }
+  res.writeHead(status, headers);
+  res.end(buffer);
+}
+function json(res, status, body) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+  res.end(`${JSON.stringify(body)}\n`);
+}
+
+function queryInt(url, name, min, max) {
+  const value = url.searchParams.get(name);
+  if (value === null || value === '') return undefined;
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < min || number > max) throw new Error(`${name} must be an integer from ${min} to ${max}`);
+  return number;
+}
+
+function queryString(url, name, max = 200) {
+  const value = url.searchParams.get(name);
+  if (value === null || value === '') return undefined;
+  if (value.length > max) throw new Error(`${name} is too long`);
+  return value;
+}
+
+function callFilters(url) {
+  return {
+    minute: queryInt(url, 'minute', 0, 1435),
+    hour: queryInt(url, 'hour', 0, 23),
+    tool: queryString(url, 'tool', 160),
+    capability: queryString(url, 'capability', 32),
+    decision: queryString(url, 'decision', 16),
+    search: queryString(url, 'search', 200)?.toLowerCase(),
+  };
+}
+
+function body(req) {
+  return new Promise((resolveBody, reject) => {
+    let raw = '';
+    req.on('data', (chunk) => {
+      raw += chunk;
+      if (raw.length > MAX_BODY) {
+        req.destroy();
+        reject(new Error('request body too large'));
+      }
+    });
+    req.on('end', () => {
+      try { resolveBody(raw ? JSON.parse(raw) : {}); } catch (error) { reject(error); }
+    });
+    req.on('error', reject);
+  });
+}
+
+function readPaths(dir) {
+  const value = readJson(paths(dir).fsPaths, null);
+  if (value === null) return { version: 1, allowed_roots: [], exclusions: [] };
+  return validatePathsConfig(value);
+}
+
+function staticFile(name) {
+  const file = resolve(STATIC_ROOT, normalize(name));
+  if (!file.startsWith(STATIC_ROOT + sep)) return null;
+  if (!['index.html', 'app.js', 'app.css'].includes(name.split('/').pop())) return null;
+  if (!existsSync(file)) return null;
+  return { file, type: MIME[extname(file)] ?? 'application/octet-stream' };
+}
+
+export function startUi({
+  dir = '.attesso',
+  cwd = process.cwd(),
+  home = homedir(),
+  port = 0,
+  open = true,
+} = {}) {
+  const ledger = resolve(dir);
+  const catalog = new Catalog(ledger);
+  const token = randomBytes(24).toString('hex');
+  const clients = new Set();
+  const tail = new LedgerTail(paths(ledger).ledger);
+  let tailTimer = null;
+
+  const authorized = (req) => {
+    const value = String(req.headers['x-bounds-token'] ?? '');
+    if (value.length !== token.length) return false;
+    return timingSafeEqual(Buffer.from(value), Buffer.from(token));
+  };
+  const sameOrigin = (req, address) => {
+    const origin = req.headers.origin;
+    if (!origin) return true;
+    const allowed = [`http://127.0.0.1:${address.port}`, `http://localhost:${address.port}`];
+    return allowed.includes(origin);
+  };
+
+  const broadcast = (entry) => {
+    const day = localDay(new Date(entry.at));
+    const message = `id: ${entry.seq}\nevent: decision\ndata: ${JSON.stringify({ day, row: rowFor(entry), seq: entry.seq })}\n\n`;
+    for (const client of clients) {
+      try {
+        if (client.res.writableLength > 1_000_000) {
+          client.res.end();
+          clients.delete(client);
+          continue;
+        }
+        client.res.write(message);
+      } catch {
+        clients.delete(client);
+      }
+    }
+  };
+
+  const poll = () => {
+    if (clients.size === 0) return;
+    try {
+      tail.read((line) => {
+        try {
+          const entry = JSON.parse(line);
+          if (entry?.seq && entry.action !== 'llm.session') broadcast(entry);
+        } catch {
+          // A malformed complete line is a ledger error; do not invent an event.
+        }
+      });
+    } catch {
+      // The ledger can be replaced while the UI is open. The next poll reopens it.
+    }
+  };
+
+  const server = createServer(async (req, res) => {
+    const host = (req.headers.host ?? '').split(':')[0];
+    if (host !== '127.0.0.1' && host !== 'localhost') return json(res, 403, { error: 'loopback only' });
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const address = server.address();
+    try {
+      if (url.pathname === '/' || url.pathname === '/index.html') {
+        const page = readFileSync(join(STATIC_ROOT, 'index.html'), 'utf8').replace('__BOUNDS_TOKEN__', token);
+        return send(req, res, 200, MIME['.html'], page);
+      }
+      if (!url.pathname.startsWith('/api/')) {
+        const file = staticFile(url.pathname.slice(1));
+        if (!file) return json(res, 404, { error: 'not found' });
+        return send(req, res, 200, file.type, readFileSync(file.file));
+      }
+      if (!authorized(req)) return json(res, 401, { error: 'missing bounds token' });
+      if (!sameOrigin(req, address)) return json(res, 403, { error: 'origin refused' });
+
+      if (url.pathname === '/api/status' && req.method === 'GET') {
+        let pathsValue;
+        try { pathsValue = readPaths(ledger); } catch (error) { pathsValue = null; }
+        return json(res, 200, { ...agentStatus({ dir: ledger, cwd, home }), paths: pathsValue });
+      }
+      if (url.pathname === '/api/calls' && req.method === 'GET') {
+        return json(res, 200, callsPayload(ledger));
+      }
+      if (url.pathname.startsWith('/api/v1/') && req.method === 'GET') {
+        try {
+          const timeZone = validateTimeZone(url.searchParams.get('tz') ?? undefined);
+          if (url.pathname === '/api/v1/summary') {
+            return json(res, 200, querySummary(catalog, { day: parseDay(url.searchParams.get('day'), timeZone), timeZone }));
+          }
+          if (url.pathname === '/api/v1/flow') {
+            return json(res, 200, queryFlow(catalog, {
+              day: parseDay(url.searchParams.get('day'), timeZone),
+              timeZone,
+              bucket: parseLimit(url.searchParams.get('bucket'), { fallback: 5, max: 60 }),
+            }));
+          }
+          if (url.pathname === '/api/v1/usage') {
+            return json(res, 200, usageForDay(catalog, {
+              day: parseDay(url.searchParams.get('day'), timeZone),
+              timeZone,
+            }));
+          }
+          if (url.pathname === '/api/v1/days') {
+            return json(res, 200, { days: queryDays(catalog, {
+              timeZone,
+              limit: parseLimit(url.searchParams.get('limit'), { fallback: 14, max: 90 }),
+            }) });
+          }
+          if (url.pathname === '/api/v1/calls') {
+            const cursor = parseCursor(url.searchParams.get('cursor'), timeZone);
+            const day = url.searchParams.get('day') ? parseDay(url.searchParams.get('day'), timeZone) : null;
+            return json(res, 200, queryPage(catalog, {
+              day,
+              timeZone,
+              after: cursor.seq,
+              limit: parseLimit(url.searchParams.get('limit'), { fallback: 100, max: 200 }),
+              filters: callFilters(url),
+            }));
+          }
+          return json(res, 404, { error: 'unknown api' });
+        } catch (error) {
+          return json(res, 400, { error: error.message });
+        }
+      }
+      if (url.pathname === '/api/events' && req.method === 'GET') {
+        res.writeHead(200, {
+          'content-type': 'text/event-stream; charset=utf-8',
+          'cache-control': 'no-store',
+          connection: 'keep-alive',
+        });
+        res.write('retry: 2000\n\n');
+        const after = Number(url.searchParams.get('after') ?? req.headers['last-event-id'] ?? 0);
+        if (isInitialised(ledger) && after > 0) {
+          try {
+            for (const entry of readEntries(ledger)) {
+              if (entry.action === 'llm.session') continue;
+              if (entry.seq <= after) continue;
+              const day = localDay(new Date(entry.at));
+              res.write(`id: ${entry.seq}\nevent: decision\ndata: ${JSON.stringify({ day, row: rowFor(entry), seq: entry.seq })}\n\n`);
+            }
+          } catch {
+            res.write('event: reset\ndata: {}\n\n');
+          }
+        }
+        const client = { res };
+        clients.add(client);
+        req.on('close', () => clients.delete(client));
+        return;
+      }
+      if (url.pathname === '/api/mode' && req.method === 'POST') {
+        try {
+          const { mode } = await body(req);
+          setModeAll(ledger, mode, { home });
+          return json(res, 200, { ok: true, mode, status: agentStatus({ dir: ledger, cwd, home }) });
+        } catch (error) { return json(res, 400, { error: error.message }); }
+      }
+      if (url.pathname === '/api/paths' && req.method === 'GET') {
+        try { return json(res, 200, readPaths(ledger)); } catch (error) { return json(res, 500, { error: error.message }); }
+      }
+      if (url.pathname === '/api/paths' && req.method === 'POST') {
+        try {
+          const next = validatePathsConfig(await body(req));
+          writeJson(paths(ledger).fsPaths, next);
+          return json(res, 200, { ok: true, paths: next });
+        } catch (error) { return json(res, 400, { error: error.message }); }
+      }
+      if (url.pathname === '/api/connect' && req.method === 'POST') {
+        try {
+          const { mode = 'observe' } = await body(req);
+          const result = connectAgent({ dir: ledger, cwd, home, write: true, mode, cli: process.argv[1] });
+          if (tail.fd === null && isInitialised(ledger)) {
+            tail.open();
+            if (!tailTimer) tailTimer = setInterval(poll, 400);
+          }
+          let pathsValue;
+          try { pathsValue = readPaths(ledger); } catch { pathsValue = null; }
+          return json(res, 200, { ok: true, result, status: { ...agentStatus({ dir: ledger, cwd, home }), paths: pathsValue } });
+        } catch (error) { return json(res, 400, { error: error.message }); }
+      }
+      return json(res, 404, { error: 'unknown api' });
+    } catch (error) {
+      return json(res, 500, { error: error.message });
+    }
+  });
+
+  const heartbeat = setInterval(() => {
+    for (const client of clients) {
+      try { client.res.write(': heartbeat\n\n'); } catch { clients.delete(client); }
+    }
+  }, 15_000);
+
+  return new Promise((resolveStart, rejectStart) => {
+    server.once('error', rejectStart);
+    server.listen(port, '127.0.0.1', () => {
+      server.removeListener('error', rejectStart);
+      const address = server.address();
+      if (isInitialised(ledger)) {
+        try {
+          tail.open();
+          tailTimer = setInterval(poll, 400);
+        } catch {
+          // The page still reads the ledger through /api/calls; the stream waits.
+        }
+      }
+      const url = `http://127.0.0.1:${address.port}/`;
+      if (open) {
+        try {
+          const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+          const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+          const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+          child.on('error', () => {});
+          child.unref();
+        } catch {
+          // A headless machine can still use the URL printed by the CLI.
+        }
+      }
+      resolveStart({
+        token,
+        port: address.port,
+        url,
+        server,
+        close: () => new Promise((resolveClose) => {
+          clearInterval(heartbeat);
+          if (tailTimer) clearInterval(tailTimer);
+          for (const client of clients) client.res.end();
+          clients.clear();
+          tail.close();
+          server.close(resolveClose);
+        }),
+      });
+    });
+  });
+}