thinknagent 0.1.22 → 0.1.24

package/lib/agent.js

@@ -6,6 +6,7 @@ const MetricsPoller = require('./metrics');
 const LogWatcher    = require('./logwatcher');
 const AlertEngine   = require('./alerts');
 const ShellBridge   = require('./shell');
+const HistoryManager = require('./history');
 const store         = require('./store');
 const chokidar      = require('chokidar');
 const fs            = require('fs');
@@ -79,12 +80,16 @@ class Agent {
     });
 
     this.alerts.conn = this.conn;
+    this.history     = new HistoryManager();
 
     this.metrics = new MetricsPoller({
       connection:    this.conn,
       gpu:           cfg.gpu || false,
       interval:      cfg.interval || 1000,
-      onMetricsEmit: (payload) => this.alerts.evaluate(payload),
+      onMetricsEmit: (payload) => {
+        this.alerts.evaluate(payload);
+        this.history.recordSnapshot(payload);
+      },
     });
 
     this.logs  = new LogWatcher({
@@ -117,6 +122,17 @@ class Agent {
       this.metrics.pollNow();
     });
 
+    this.conn.socket.on('agent:get_history', ({ hours, requestId }) => {
+      const targetHours = typeof hours === 'number' ? hours : 72;
+      console.log(`[agent] Historical metrics requested (${targetHours}h)`);
+      const historyData = this.history.getHistory(targetHours);
+      this.conn.socket.emit('agent:history_data', {
+        requestId,
+        hours: targetHours,
+        history: historyData
+      });
+    });
+
     this.conn.socket.on('agent:send_logs', () => {
       console.log('[agent] Logs refresh requested');
       if (this.logs && this.logs.logPaths) {

package/lib/alerts.js

@@ -44,7 +44,7 @@ class AlertEngine {
         const elapsed = (now - state.firstTriggeredAt) / 1000; // seconds
         if (elapsed >= rule.for && !state.fired) {
           state.fired = true;
-          this._fire(rule, val);
+          this._fire(rule, val, metrics);
         }
       } else {
         // Condition cleared
@@ -57,17 +57,19 @@ class AlertEngine {
     }
   }
 
-  _fire(rule, currentValue) {
+  _fire(rule, currentValue, metrics = null) {
     console.warn(`[alerts] FIRING: ${rule.id} — ${rule.metric} ${rule.op} ${rule.value} (current: ${currentValue})`);
     this.conn.emit('agent:alert', {
-      id:       rule.id,
-      metric:   rule.metric,
-      op:       rule.op,
-      threshold: rule.value,
-      current:  currentValue,
-      severity: rule.severity || 'warning',
-      status:   'active',
-      firedAt:  Date.now(),
+      id:           rule.id,
+      metric:       rule.metric,
+      op:           rule.op,
+      threshold:    rule.value,
+      current:      currentValue,
+      severity:     rule.severity || 'warning',
+      status:       'active',
+      firedAt:      Date.now(),
+      diagnostics:  metrics?.diagnostics || null,
+      topProcesses: metrics?.processes?.top || [],
     });
   }
 

package/lib/connect.js

@@ -143,6 +143,24 @@ s.on('agent:approved', ({ agentToken, role, roomId }) => {
       process.exit(0);
     });
 
+    // ── Periodic HMAC Challenge-Response Zero-Trust Protocol ───────────────────
+    s.on('agent:auth_challenge', ({ challenge, ts }) => {
+      const cfg = store.read();
+      const token = cfg.agentToken || this.agentToken;
+      const crypto = require('crypto');
+      if (!token) return;
+
+      const raw = `${challenge}:${ts}:${cfg.agentId}`;
+      const signature = crypto.createHmac('sha256', token).update(raw).digest('hex');
+
+      s.emit('agent:auth_challenge_response', {
+        challenge,
+        ts,
+        signature,
+        agentId: cfg.agentId
+      });
+    });
+
     s.on('connect_error', (err) => {
       console.error(`[thinknagent] Connection error: ${err.message}`);
     });

package/lib/history.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const CONFIG_DIR = path.join(HOME, '.thinknagent');
+const HISTORY_DIR = path.join(CONFIG_DIR, 'history');
+const RETENTION_DAYS = 3;
+const SNAPSHOT_INTERVAL_MS = 30000; // Snapshot to disk every 30 seconds
+
+class HistoryManager {
+  constructor() {
+    this._ensureDir();
+    this._lastSnapshotTime = 0;
+  }
+
+  _ensureDir() {
+    try {
+      if (!fs.existsSync(HISTORY_DIR)) {
+        fs.mkdirSync(HISTORY_DIR, { recursive: true, mode: 0o700 });
+      }
+    } catch (err) {
+      console.warn('[history] Failed to create history directory:', err.message);
+    }
+  }
+
+  _getDateKey(timestamp = Date.now()) {
+    const d = new Date(timestamp);
+    const y = d.getUTCFullYear();
+    const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(d.getUTCDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+  }
+
+  _getFilePathForDate(dateKey) {
+    return path.join(HISTORY_DIR, `metrics_${dateKey}.jsonl`);
+  }
+
+  // Called on every metrics tick (we sample every 30s to disk)
+  recordSnapshot(metrics) {
+    const now = Date.now();
+    if (now - this._lastSnapshotTime < SNAPSHOT_INTERVAL_MS) {
+      return;
+    }
+    this._lastSnapshotTime = now;
+
+    try {
+      const dateKey = this._getDateKey(now);
+      const filePath = this._getFilePathForDate(dateKey);
+
+      const entry = {
+        ts: now,
+        cpu: metrics.cpu?.usage ?? 0,
+        load: metrics.cpu?.loadAvg ?? 0,
+        mem: metrics.memory?.usedPct ?? 0,
+        memUsedMB: Math.round((metrics.memory?.used || 0) / (1024 * 1024)),
+        rxSec: metrics.network?.[0]?.rxSec ?? 0,
+        txSec: metrics.network?.[0]?.txSec ?? 0,
+        procs: metrics.processes?.total ?? 0,
+        diag: metrics.diagnostics?.hasSpike ? metrics.diagnostics : undefined,
+      };
+
+      // Append atomic line to daily disk file (survives crashes, restarts, reboots)
+      fs.appendFileSync(filePath, JSON.stringify(entry) + '\n', { encoding: 'utf8', mode: 0o600 });
+
+      // Run daily pruning check
+      this._pruneOldFiles();
+    } catch (err) {
+      console.error('[history] Error writing snapshot to disk:', err.message);
+    }
+  }
+
+  // Deletes any history files older than RETENTION_DAYS (3 days)
+  _pruneOldFiles() {
+    try {
+      const files = fs.readdirSync(HISTORY_DIR);
+      const cutoffTime = Date.now() - (RETENTION_DAYS * 24 * 60 * 60 * 1000);
+      const cutoffDateKey = this._getDateKey(cutoffTime);
+
+      for (const file of files) {
+        if (!file.startsWith('metrics_') || !file.endsWith('.jsonl')) continue;
+        const fileDateKey = file.replace('metrics_', '').replace('.jsonl', '');
+        if (fileDateKey < cutoffDateKey) {
+          try {
+            fs.unlinkSync(path.join(HISTORY_DIR, file));
+            console.log(`[history] Pruned old history file: ${file}`);
+          } catch (e) {}
+        }
+      }
+    } catch (err) {
+      // ignore
+    }
+  }
+
+  // Retrieve historical data across the last N hours (up to 72 hours / 3 days)
+  getHistory(hours = 72) {
+    const minTimestamp = Date.now() - (hours * 60 * 60 * 1000);
+    const records = [];
+
+    try {
+      if (!fs.existsSync(HISTORY_DIR)) return [];
+
+      const files = fs.readdirSync(HISTORY_DIR)
+        .filter(f => f.startsWith('metrics_') && f.endsWith('.jsonl'))
+        .sort(); // ascending date order
+
+      for (const file of files) {
+        const fullPath = path.join(HISTORY_DIR, file);
+        const content = fs.readFileSync(fullPath, 'utf8');
+        const lines = content.split('\n');
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const data = JSON.parse(line);
+            if (data.ts >= minTimestamp) {
+              records.push(data);
+            }
+          } catch (e) {}
+        }
+      }
+
+      // If more than 300 points requested, downsample evenly to keep UI charts silky smooth
+      if (records.length > 300) {
+        const step = Math.ceil(records.length / 300);
+        const sampled = [];
+        for (let i = 0; i < records.length; i += step) {
+          sampled.push(records[i]);
+        }
+        return sampled;
+      }
+
+      return records;
+    } catch (err) {
+      console.error('[history] Error reading history from disk:', err.message);
+      return [];
+    }
+  }
+}
+
+module.exports = HistoryManager;

package/lib/metrics.js

@@ -47,6 +47,12 @@ class MetricsPoller {
         si.processes(),
       ]);
 
+      // True active process memory (excluding OS buffer / page cache)
+      const realUsedBytes = (typeof mem.available === 'number' && mem.available > 0)
+        ? (mem.total - mem.available)
+        : (mem.active || (mem.used - (mem.buffcache || 0)));
+      const realUsedPct = parseFloat(Math.min(100, Math.max(0, (realUsedBytes / mem.total) * 100)).toFixed(1));
+
       const payload = {
         ts: Date.now(),
         cpu: {
@@ -55,10 +61,15 @@ class MetricsPoller {
           loadAvg: cpu.avgLoad ?? 0,
         },
         memory: {
-          total:   mem.total,
-          used:    mem.used,
-          free:    mem.free,
-          usedPct: parseFloat(((mem.used / mem.total) * 100).toFixed(1)),
+          total:       mem.total,
+          active:      realUsedBytes,
+          activePct:   realUsedPct,
+          buffcache:   mem.buffcache || Math.max(0, mem.used - realUsedBytes),
+          rawUsed:     mem.used,
+          rawUsedPct:  parseFloat(((mem.used / mem.total) * 100).toFixed(1)),
+          free:        mem.available || mem.free,
+          used:        realUsedBytes,
+          usedPct:     realUsedPct,
         },
         disk: disk.map(d => ({
           fs:      d.fs,
@@ -128,6 +139,79 @@ class MetricsPoller {
         }
       }
 
+      // ─── Automated Spike Diagnostic & Root Cause Engine ────────────────────────
+      const curCpuUsage = parseFloat(cpu.currentLoad.toFixed(1));
+      const curMemPct   = realUsedPct;
+
+      // Filter real user/application processes with actual resource footprint
+      const sortedMemProcs = (procs.list || [])
+        .filter(p => p && p.pid > 1 && (p.pmem > 0.5 || p.pcpu > 0.5))
+        .sort((a, b) => (b.pmem || 0) - (a.pmem || 0));
+      const topMemProc = sortedMemProcs[0] || (procs.list || []).sort((a, b) => (b.pmem || 0) - (a.pmem || 0))[0] || null;
+
+      const sortedCpuProcs = (procs.list || [])
+        .filter(p => p && p.pid > 1 && (p.pcpu > 0.5 || p.pmem > 0.5))
+        .sort((a, b) => (b.pcpu || 0) - (a.pcpu || 0));
+      const topCpuProc = sortedCpuProcs[0] || (procs.list || []).sort((a, b) => (b.pcpu || 0) - (a.pcpu || 0))[0] || null;
+
+      let diagnostics = {
+        hasSpike: false,
+        type: 'nominal',
+        culprit: null,
+        deltaPct: 0,
+        explanation: 'System resource levels nominal and stable.'
+      };
+
+      const prevMem = this._lastMemPct !== undefined ? this._lastMemPct : curMemPct;
+      const prevCpu = this._lastCpuUsage !== undefined ? this._lastCpuUsage : curCpuUsage;
+      const memDelta = parseFloat((curMemPct - prevMem).toFixed(1));
+      const cpuDelta = parseFloat((curCpuUsage - prevCpu).toFixed(1));
+      this._lastMemPct = curMemPct;
+      this._lastCpuUsage = curCpuUsage;
+
+      const topMemMB = topMemProc ? Math.round(((topMemProc.pmem || 0) / 100) * (mem.total / (1024 * 1024))) : 0;
+      const topMemPct = topMemProc ? parseFloat((topMemProc.pmem || 0).toFixed(1)) : 0;
+      const hasRealMemCulprit = topMemProc && (topMemPct >= 3.0 || topMemMB >= 35);
+
+      // Trigger spike only on sudden surge OR critically high memory with an identified culprit
+      if (memDelta >= 5.0 || (curMemPct >= 90 && hasRealMemCulprit)) {
+        diagnostics.hasSpike = true;
+        diagnostics.type = 'memory';
+        diagnostics.deltaPct = memDelta;
+        if (hasRealMemCulprit) {
+          diagnostics.culprit = {
+            pid: topMemProc.pid,
+            name: topMemProc.name,
+            command: topMemProc.command ? topMemProc.command.slice(0, 80) : topMemProc.name,
+            memPct: topMemPct,
+            memMB: topMemMB,
+            cpu: parseFloat((topMemProc.pcpu || 0).toFixed(1))
+          };
+          diagnostics.explanation = `Memory surge detected (${curMemPct}% RAM, delta: ${memDelta >= 0 ? '+' : ''}${memDelta}%). Primary consumer is "${topMemProc.name}" (PID ${topMemProc.pid}) utilizing ${topMemPct}% (${topMemMB} MB). Probable cause: Rapid memory allocation, large dataset buffer in memory, or memory leak.`;
+        } else {
+          diagnostics.explanation = `Memory load is elevated (${curMemPct}% RAM, delta: ${memDelta >= 0 ? '+' : ''}${memDelta}%), distributed across system caches and background services. No single runaway process.`;
+        }
+      } else if (cpuDelta >= 30.0 || (curCpuUsage >= 85 && topCpuProc && (topCpuProc.pcpu || 0) >= 10.0)) {
+        const topCpuVal = topCpuProc ? parseFloat((topCpuProc.pcpu || 0).toFixed(1)) : 0;
+        diagnostics.hasSpike = true;
+        diagnostics.type = 'cpu';
+        diagnostics.deltaPct = cpuDelta;
+        if (topCpuProc && topCpuVal >= 5.0) {
+          diagnostics.culprit = {
+            pid: topCpuProc.pid,
+            name: topCpuProc.name,
+            command: topCpuProc.command ? topCpuProc.command.slice(0, 80) : topCpuProc.name,
+            cpu: topCpuVal,
+            memPct: parseFloat((topCpuProc.pmem || 0).toFixed(1))
+          };
+          diagnostics.explanation = `High CPU workload spike detected (${curCpuUsage}% CPU, delta: ${cpuDelta >= 0 ? '+' : ''}${cpuDelta}%). Primary consumer is "${topCpuProc.name}" (PID ${topCpuProc.pid}) utilizing ${topCpuVal}% CPU. Probable cause: Intensive computation, complex query/loop execution, or heavy background processing.`;
+        } else {
+          diagnostics.explanation = `High CPU utilization (${curCpuUsage}% CPU, delta: ${cpuDelta >= 0 ? '+' : ''}${cpuDelta}%) spread across multiple threads.`;
+        }
+      }
+
+      payload.diagnostics = diagnostics;
+
       this._history.push({ ts: payload.ts, cpu: payload.cpu.usage, mem: payload.memory.usedPct });
       if (this._history.length > 60) this._history.shift();
       payload.history = this._history;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinknagent",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "ThinkNCollab server agent & MCP server — metrics, logs, alerts, shell bridge, AI planning",
   "main": "lib/agent.js",
   "author": "ThinkNCollab Team <raman@thinkncollab.com>",