thatcher 1.0.4

package/src/lib/request-tracker.js

@@ -0,0 +1,43 @@
+import { recordRequest, recordError } from '@/lib/metrics-collector.js'
+
+function wrapHandler(handler, metadata = {}) {
+  return async (request, context) => {
+    const start = process.hrtime.bigint()
+    const method = request.method
+    const path = new URL(request.url).pathname
+
+    try {
+      const response = await handler(request, context)
+      const duration = Number(process.hrtime.bigint() - start) / 1000000
+      const status = response.status || 200
+
+      recordRequest(path, method, duration, status)
+
+      return response
+    } catch (err) {
+      const duration = Number(process.hrtime.bigint() - start) / 1000000
+
+      recordRequest(path, method, duration, 500)
+      recordError(path, method, err.message, err.stack)
+
+      throw err
+    }
+  }
+}
+
+function trackRequest(path, method, duration, status) {
+  recordRequest(path, method, duration, status)
+}
+
+function trackError(path, method, error, stack) {
+  recordError(path, method, error, stack)
+}
+
+export { wrapHandler, trackRequest, trackError }
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__requestTracker = {
+    trackRequest,
+    trackError
+  }
+}

package/src/lib/resource-hints.js

@@ -0,0 +1,29 @@
+export function generateResourceHints(pathname) {
+  const hints = [];
+  
+  hints.push({ rel: 'preload', href: '/ui/client.js', as: 'script' });
+  hints.push({ rel: 'preload', href: '/ui/styles.css', as: 'style' });
+  hints.push({ rel: 'preload', href: '/lib/webjsx/runtime.js', as: 'script' });
+  
+  hints.push({ rel: 'dns-prefetch', href: '//fonts.googleapis.com' });
+  
+  if (pathname === '/' || pathname === '/login') {
+    hints.push({ rel: 'prefetch', href: '/api/friday/engagement' });
+  }
+  
+  if (pathname.includes('/engagement')) {
+    hints.push({ rel: 'prefetch', href: '/api/friday/rfi' });
+    hints.push({ rel: 'prefetch', href: '/api/mwr/review' });
+  }
+  
+  return hints;
+}
+
+export function renderResourceHints(hints) {
+  return hints.map(h => {
+    const attrs = Object.entries(h)
+      .map(([k, v]) => `${k}="${v}"`)
+      .join(' ');
+    return `<link ${attrs}>`;
+  }).join('\n  ');
+}

package/src/lib/resource-monitor.js

@@ -0,0 +1,117 @@
+import os from 'os'
+import fs from 'fs'
+import { recordResource } from '@/lib/metrics-collector.js'
+
+let monitoringInterval = null
+let dbPath = null
+
+function getCPUUsage() {
+  const cpus = os.cpus()
+  let totalIdle = 0
+  let totalTick = 0
+
+  cpus.forEach(cpu => {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type]
+    }
+    totalIdle += cpu.times.idle
+  })
+
+  const idle = totalIdle / cpus.length
+  const total = totalTick / cpus.length
+  const usage = 1 - (idle / total)
+
+  return Math.max(0, Math.min(1, usage))
+}
+
+function getMemoryUsage() {
+  const totalMem = os.totalmem()
+  const freeMem = os.freemem()
+  const usedMem = totalMem - freeMem
+
+  return {
+    total: totalMem,
+    used: usedMem,
+    free: freeMem,
+    percentage: usedMem / totalMem
+  }
+}
+
+function getDiskUsage() {
+  if (!dbPath) return null
+
+  try {
+    const stats = fs.statSync(dbPath)
+    const totalSpace = 1024 * 1024 * 1024 * 100
+    const usedSpace = stats.size
+
+    return {
+      total: totalSpace,
+      used: usedSpace,
+      percentage: usedSpace / totalSpace
+    }
+  } catch (err) {
+    return null
+  }
+}
+
+function collectResources() {
+  try {
+    const cpu = getCPUUsage()
+    const memory = getMemoryUsage()
+    const disk = getDiskUsage()
+
+    recordResource(
+      cpu,
+      memory.percentage,
+      disk?.percentage
+    )
+
+    return { cpu, memory, disk }
+  } catch (err) {
+    console.error('[ResourceMonitor] Collection error:', err)
+    return null
+  }
+}
+
+function startMonitoring(interval = 5000, databasePath = null) {
+  if (monitoringInterval) {
+    stopMonitoring()
+  }
+
+  dbPath = databasePath
+
+  monitoringInterval = setInterval(() => {
+    collectResources()
+  }, interval)
+
+}
+
+function stopMonitoring() {
+  if (monitoringInterval) {
+    clearInterval(monitoringInterval)
+    monitoringInterval = null
+  }
+}
+
+function getCurrentResources() {
+  return collectResources()
+}
+
+export {
+  getCPUUsage,
+  getMemoryUsage,
+  getDiskUsage,
+  collectResources,
+  startMonitoring,
+  stopMonitoring,
+  getCurrentResources
+}
+
+if (typeof globalThis !== 'undefined') {
+  globalThis.__resources = {
+    getCurrentResources,
+    startMonitoring,
+    stopMonitoring
+  }
+}

package/src/lib/response-formatter.js

@@ -0,0 +1,80 @@
+/**
+ * Response Formatter - Standardized API response helpers
+ */
+
+import { HTTP } from '../config/constants.js';
+
+/**
+ * Successful response with data
+ * @param {any} data
+ * @returns {Response} NextResponse-compatible
+ */
+export function ok(data) {
+  return new Response(JSON.stringify(data), {
+    status: HTTP.OK,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+/**
+ * Created response (201)
+ * @param {any} data
+ * @returns {Response}
+ */
+export function created(data) {
+  return new Response(JSON.stringify(data), {
+    status: HTTP.CREATED,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+/**
+ * Paginated response
+ * @param {Array} items
+ * @param {object} pagination
+ * @returns {Response}
+ */
+export function paginated(items, pagination) {
+  return new Response(JSON.stringify({
+    items,
+    pagination,
+  }), {
+    status: HTTP.OK,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+/**
+ * No content response (204)
+ * @returns {Response}
+ */
+export function noContent() {
+  return new Response(null, { status: HTTP.NO_CONTENT });
+}
+
+/**
+ * Error response
+ * @param {string} message
+ * @param {number} status
+ * @param {string} code
+ * @returns {Response}
+ */
+export function error(message, status = HTTP.INTERNAL_ERROR, code = 'ERROR') {
+  return new Response(JSON.stringify({ error: message, code }), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+/**
+ * With metadata wrapper
+ * @param {any} data
+ * @param {number} status
+ * @param {string} type
+ * @returns {object}
+ */
+export function withMetadata(data, status, type = 'success') {
+  return { ...data, _meta: { status, type, timestamp: Date.now() } };
+}
+
+import { HTTP } from '../config/constants.js';

package/src/lib/route-helpers.js

@@ -0,0 +1,33 @@
+import { getSpec, getNavItems } from '@/config/spec-helpers';
+import { get, getChildren } from '@/engine';
+import { can } from '@/services/permission.service';
+import { withPageAuth } from '@/lib/auth-middleware';
+import { notFound } from '@/lib/next-polyfills';
+import { loadFormOptions } from '@/lib/utils';
+
+export { withPageAuth as requireEntityAccess };
+
+export async function getEntityData(entityName, id, options = {}) {
+  const { user, spec } = await withPageAuth(entityName, 'view', options);
+  const data = get(entityName, id);
+  if (!data) notFound();
+  const children = spec.children ? Object.fromEntries(Object.entries(spec.children).map(([k, def]) => [k, getChildren(entityName, id, def)])) : {};
+  return { user, spec, data, children };
+}
+
+export async function getFormContext(entityName, id = null, action = 'create') {
+  const { user, spec } = await withPageAuth(entityName, action, { redirectTo: id ? `/${entityName}/${id}` : `/${entityName}` });
+  const data = id ? get(entityName, id) : {};
+  if (id && !data) notFound();
+  const options = await loadFormOptions(spec);
+  return { user, spec, data, options };
+}
+
+export const getPageProps = (user, spec) => ({ user, nav: getNavItems(), canCreate: can(user, spec, 'create'), canEdit: can(user, spec, 'edit'), canDelete: can(user, spec, 'delete') });
+
+const createMeta = (fn) => (...args) => { try { return fn(...args); } catch { return { title: 'Not Found' }; } };
+
+export const listMetadata = createMeta((entity) => ({ title: getSpec(entity).labelPlural }));
+export const detailMetadata = createMeta((entity, id) => { const spec = getSpec(entity), data = get(entity, id); return { title: data?.name || data?.email || spec.label }; });
+export const newMetadata = createMeta((entity) => ({ title: `New ${getSpec(entity).label}` }));
+export const editMetadata = createMeta((entity, id) => { const spec = getSpec(entity), data = get(entity, id); return { title: `Edit ${data?.name || spec.label}` }; });

package/src/lib/route-resolver.js

@@ -0,0 +1,142 @@
+import fs from 'fs';
+import path from 'path';
+
+export function resolveParamRoute(baseDir, segments) {
+  if (!fs.existsSync(baseDir)) return null;
+  if (segments.length === 0) {
+    const r = path.join(baseDir, 'route.js');
+    return fs.existsSync(r) ? r : null;
+  }
+  const [seg, ...rest] = segments;
+  const entries = fs.readdirSync(baseDir, { withFileTypes: true }).filter(e => e.isDirectory());
+  for (const entry of entries) {
+    const name = entry.name;
+    if (name === seg || name.startsWith('[')) {
+      const found = resolveParamRoute(path.join(baseDir, name), rest);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+export function resolveSpecificParams(routeFile, pathParts) {
+  const result = {};
+  const routeRelative = routeFile.replace(/.*src\/app\/api\//, '').replace(/\/route\.js$/, '');
+  const routeSegments = routeRelative.split('/');
+  const urlSegments = pathParts.slice(0);
+  for (let i = 0; i < routeSegments.length && i < urlSegments.length; i++) {
+    const seg = routeSegments[i];
+    if (seg.startsWith('[') && seg.endsWith(']')) {
+      const paramName = seg.replace(/^\[\.\.\./, '').replace(/[\[\]]/g, '');
+      result[paramName] = urlSegments[i];
+    }
+  }
+  return result;
+}
+
+function singularize(name) {
+  if (name.endsWith('ies')) return name.slice(0, -3) + 'y';
+  if (name.endsWith('ses') || name.endsWith('xes') || name.endsWith('zes')) return name.slice(0, -2);
+  if (name.endsWith('s') && !name.endsWith('ss')) return name.slice(0, -1);
+  return name;
+}
+
+export function buildNestedRoutePath(baseDir, domain, parentEntity, childParts) {
+  if (childParts.length === 0) return null;
+
+  function buildSegments(parentParam, childParamFn) {
+    const segs = [domain, parentEntity, parentParam];
+    for (let i = 0; i < childParts.length; i++) {
+      if (i % 2 === 0) segs.push(childParts[i]);
+      else segs.push(childParamFn(i));
+    }
+    return path.join(baseDir, 'src/app/api', ...segs, 'route.js');
+  }
+
+  const variants = [
+    () => buildSegments('[id]', (i) => `[${childParts[i - 1]}Id]`),
+    () => buildSegments('[id]', (i) => `[${singularize(childParts[i - 1])}Id]`),
+    () => buildSegments(`[${parentEntity}Id]`, (i) => `[${childParts[i - 1]}Id]`),
+    () => buildSegments(`[${parentEntity}Id]`, (i) => `[${singularize(childParts[i - 1])}Id]`),
+    () => buildSegments('[id]', () => `[${childParts[0]}Id]`),
+    () => buildSegments('[id]', () => `[${singularize(childParts[0])}Id]`),
+  ];
+
+  for (const variant of variants) {
+    const candidate = variant();
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return variants[0]();
+}
+
+const DOMAINS = ['friday', 'mwr'];
+
+export function resolveRoute(__dirname, pathname, url) {
+  const pathParts = pathname.slice(5).split('/').filter(Boolean);
+  const firstPart = pathParts[0];
+  const isDomain = DOMAINS.includes(firstPart);
+  let routeFile = null;
+  let params = {};
+
+  if (isDomain) {
+    const domain = firstPart;
+    const domainParts = pathParts.slice(1);
+
+    const specificCheck = path.join(__dirname, `src/app/api/${domain}/${domainParts.join('/')}/route.js`);
+    if (fs.existsSync(specificCheck)) {
+      routeFile = specificCheck;
+      params = resolveSpecificParams(specificCheck, pathParts);
+    }
+
+    if (!routeFile && domainParts.length >= 3) {
+      const parentEntity = domainParts[0];
+      const childParts = domainParts.slice(2);
+      const parentId = domainParts[1];
+      const childEntity = childParts[0];
+      const childId = childParts[1] || null;
+
+      const nestedSpecific = buildNestedRoutePath(__dirname, domain, parentEntity, childParts);
+      if (nestedSpecific && fs.existsSync(nestedSpecific)) {
+        routeFile = nestedSpecific;
+        params = resolveSpecificParams(nestedSpecific, pathParts);
+      }
+
+      if (!routeFile) {
+        routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
+        url.searchParams.set('domain', domain);
+        params = { entity: childEntity, path: childId ? [childId] : [], parentEntity, parentId };
+      }
+    }
+
+    if (!routeFile && domainParts.length >= 1) {
+      const entity = domainParts[0];
+      const entityPath = domainParts.slice(1);
+      routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
+      url.searchParams.set('domain', domain);
+      params = { entity, path: entityPath };
+    }
+  }
+
+  if (!routeFile && firstPart) {
+    const exactRoute = path.join(__dirname, `src/app/api/${pathParts.join('/')}/route.js`);
+    if (fs.existsSync(exactRoute)) {
+      routeFile = exactRoute;
+      params = resolveSpecificParams(exactRoute, pathParts);
+    }
+  }
+
+  if (!routeFile && firstPart) {
+    const paramRouteFile = resolveParamRoute(path.join(__dirname, 'src/app/api', firstPart), pathParts.slice(1));
+    if (paramRouteFile) {
+      routeFile = paramRouteFile;
+      params = resolveSpecificParams(paramRouteFile, pathParts);
+    }
+  }
+
+  if (!routeFile) {
+    routeFile = path.join(__dirname, 'src/app/api/[entity]/[[...path]]/route.js');
+    params = { entity: firstPart, path: pathParts.slice(1) };
+  }
+
+  return { routeFile, params, isDomain, firstPart, pathParts };
+}

package/src/lib/safe-json.js

@@ -0,0 +1,8 @@
+export const safeJsonParse = (str, fallback = null) => {
+  try {
+    return JSON.parse(str || 'null') ?? fallback;
+  } catch {
+    console.warn('[SafeJSON] Parse failed:', str?.substring(0, 50));
+    return fallback;
+  }
+};

package/src/lib/server-bootstrap.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+
+export function loadEnv(filePath) {
+  try {
+    const envFile = fs.readFileSync(filePath, 'utf-8');
+    envFile.split('\n').forEach(line => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) return;
+      const [key, ...valueParts] = trimmed.split('=');
+      const value = valueParts.join('=').replace(/^['"]|['"]$/g, '');
+      if (key) process.env[key] = value;
+    });
+  } catch (e) {
+    console.warn('[Server] .env file not loaded:', e.message);
+  }
+}
+
+export function setupProcessGuards() {
+  process.on('uncaughtException', (err) => {
+    console.error('[FATAL] Uncaught exception (process kept alive):', err?.message || err);
+    if (err?.stack) console.error(err.stack);
+  });
+  process.on('unhandledRejection', (reason) => {
+    console.error('[FATAL] Unhandled rejection (process kept alive):', reason?.message || reason);
+    if (reason?.stack) console.error(reason.stack);
+  });
+}
+
+export function setupHotReload(__dirname, moduleCache, onConfigReset) {
+  const watchedDirs = ['src/config', 'src/app/api', 'src/ui', 'src/plugins'].map(d => path.join(__dirname, d));
+  watchedDirs.forEach((dir) => {
+    if (!fs.existsSync(dir)) return;
+    try {
+      const watcher = fs.watch(dir, { recursive: true }, async (eventType, filename) => {
+        if (filename && (filename.endsWith('.js') || filename.endsWith('.jsx') || filename.endsWith('.yml'))) {
+          moduleCache.clear();
+          globalThis.__reloadTs__ = Date.now();
+          console.log(`[Hot] Invalidated: ${filename}`);
+          if (filename.endsWith('master-config.yml') || filename.includes('master-config')) {
+            try {
+              const { resetConfigEngine } = await import('./config-generator-engine.js');
+              resetConfigEngine();
+              onConfigReset?.();
+            } catch (e) { console.log('[Hot] Could not reset config engine:', e.message); }
+          }
+        }
+      });
+      watcher.on('error', (err) => console.error(`[Hot] Watcher error on ${dir}:`, err.message));
+    } catch (err) { console.error(`[Hot] Failed to watch ${dir}:`, err.message); }
+  });
+}
+
+export async function loadModule(moduleCache, filePath) {
+  const cached = moduleCache.get(filePath);
+  if (cached) return cached;
+  const module = await import(`file://${filePath}?t=${Date.now()}`);
+  moduleCache.set(filePath, module);
+  return module;
+}
+
+export function setSecurityHeaders(res, nodeEnv) {
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('X-XSS-Protection', '1; mode=block');
+  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+  res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
+  res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+  res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: https:; font-src 'self' https://fonts.gstatic.com data:; connect-src 'self' wss: ws:; frame-ancestors 'none'");
+  if (nodeEnv === 'production') res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+}

package/src/lib/stage-pipeline.js

@@ -0,0 +1,153 @@
+export function createStagePipeline(options = {}) {
+  const {
+    stages = [],
+    currentStageIndex = 0,
+    onStageClick = null,
+    readOnly = false
+  } = options;
+
+  const container = document.createElement('div');
+  container.className = 'stage-pipeline';
+  container.style.cssText = `
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 1rem;
+    background: white;
+    border-radius: 8px;
+    border: 1px solid #eee;
+  `;
+
+  stages.forEach((stage, idx) => {
+    const isComplete = idx < currentStageIndex;
+    const isCurrent = idx === currentStageIndex;
+    const isUpcoming = idx > currentStageIndex;
+
+    const stageItem = document.createElement('div');
+    stageItem.className = `stage-item stage-${isComplete ? 'complete' : isCurrent ? 'current' : 'upcoming'}`;
+    stageItem.style.cssText = `
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 0.5rem;
+      flex: 1;
+      cursor: ${!readOnly && onStageClick ? 'pointer' : 'default'};
+      transition: all 0.2s;
+    `;
+
+    const circle = document.createElement('div');
+    circle.style.cssText = `
+      width: 40px;
+      height: 40px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-weight: 600;
+      font-size: 0.875rem;
+      color: white;
+      background: ${isComplete ? '#28a745' : isCurrent ? '#007bff' : '#e0e0e0'};
+      border: 2px solid ${isCurrent ? '#0056b3' : 'transparent'};
+      transition: all 0.2s;
+    `;
+
+    if (isComplete) {
+      circle.textContent = '✓';
+    } else {
+      circle.textContent = idx + 1;
+    }
+
+    const label = document.createElement('div');
+    label.style.cssText = `
+      text-align: center;
+      font-size: 0.75rem;
+      font-weight: ${isCurrent ? '600' : '500'};
+      color: ${isCurrent ? '#007bff' : isComplete ? '#28a745' : '#999'};
+      max-width: 80px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    `;
+    label.textContent = stage.label || stage.name || `Stage ${idx + 1}`;
+
+    if (idx < stages.length - 1) {
+      const connector = document.createElement('div');
+      connector.style.cssText = `
+        position: absolute;
+        width: calc(100% / ${stages.length} - 1rem);
+        height: 2px;
+        top: 20px;
+        left: calc(${idx * (100 / stages.length) + 50 / stages.length}%);
+        background: ${isComplete || (isCurrent && idx < currentStageIndex) ? '#28a745' : '#e0e0e0'};
+        transition: all 0.2s;
+      `;
+    }
+
+    stageItem.appendChild(circle);
+    stageItem.appendChild(label);
+
+    if (!readOnly && onStageClick) {
+      stageItem.onmouseover = () => {
+        circle.style.transform = 'scale(1.1)';
+      };
+      stageItem.onmouseout = () => {
+        circle.style.transform = 'scale(1)';
+      };
+      stageItem.onclick = () => {
+        onStageClick(idx, stage);
+      };
+    }
+
+    container.appendChild(stageItem);
+  });
+
+  return {
+    element: container,
+    setCurrentStage: (idx) => {
+      container.querySelectorAll('.stage-item').forEach((el, i) => {
+        const circle = el.querySelector('div:first-child');
+        const label = el.querySelector('div:last-child');
+
+        if (i < idx) {
+          circle.style.background = '#28a745';
+          circle.textContent = '✓';
+          label.style.color = '#28a745';
+        } else if (i === idx) {
+          circle.style.background = '#007bff';
+          label.style.color = '#007bff';
+          label.style.fontWeight = '600';
+        } else {
+          circle.style.background = '#e0e0e0';
+          label.style.color = '#999';
+          label.style.fontWeight = '500';
+        }
+      });
+    }
+  };
+}
+
+export function renderStageSelector(stages, currentIndex, onChange) {
+  const select = document.createElement('select');
+  select.style.cssText = `
+    padding: 0.5rem;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 1rem;
+    cursor: pointer;
+  `;
+
+  stages.forEach((stage, idx) => {
+    const option = document.createElement('option');
+    option.value = idx;
+    option.textContent = stage.label || stage.name || `Stage ${idx + 1}`;
+    if (idx === currentIndex) option.selected = true;
+    select.appendChild(option);
+  });
+
+  select.onchange = () => {
+    const newIdx = parseInt(select.value);
+    if (onChange) onChange(newIdx, stages[newIdx]);
+  };
+
+  return select;
+}