thinknagent 0.1.20 → 0.1.23

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/logwatcher.js

@@ -4,6 +4,8 @@ const fs      = require('fs');
 const path    = require('path');
 const chokidar = require('chokidar');
 const { EventEmitter } = require('events');
+const { encryptE2EE }  = require('./e2ee');
+const store            = require('./store');
 
 const BUFFER_LINES = 100;
 const CHUNK_DELAY  = 50;
@@ -24,7 +26,7 @@ class LogWatcher extends EventEmitter {
     for (const p of this.logPaths) {
       this._watch(p);
     }
-    console.log(`[logs] Watching ${this.logPaths.length} file(s)`);
+    console.log(`[logs] Watching ${this.logPaths.length} file(s) (AES-256 E2EE active)`);
   }
 
   stop() {
@@ -66,37 +68,47 @@ class LogWatcher extends EventEmitter {
     });
 
     watcher.on('change', (fpath, stats) => {
-      const newSize = stats ? stats.size : fs.statSync(absPath).size;
+      try {
+        if (!fs.existsSync(absPath)) return;
+        const newSize = stats ? stats.size : fs.statSync(absPath).size;
 
-      if (newSize < state.size) {
-        // log rotated — reset
-        state.size = 0;
-      }
+        if (newSize < state.size) {
+          // log rotated — reset
+          state.size = 0;
+        }
+
+        const newBytes = newSize - state.size;
+        if (newBytes <= 0) return;
 
-      const newBytes = newSize - state.size;
-      if (newBytes <= 0) return;
-
-      const buf = Buffer.alloc(newBytes);
-      const fd  = fs.openSync(absPath, 'r');
-      fs.readSync(fd, buf, 0, newBytes, state.size);
-      fs.closeSync(fd);
-      state.size = newSize;
-
-      const newLines = buf.toString('utf8').split('\n').filter(Boolean);
-      state.lines.push(...newLines);
-
-      clearTimeout(state.timer);
-      state.timer = setTimeout(() => {
-        const toSend = state.lines.splice(0);
-        if (toSend.length) {
-          this.conn.emit('agent:logs', {
-            file:  absPath,
-            lines: toSend.map(l => ({ ts: Date.now(), text: l })),
-          });
+        const buf = Buffer.alloc(newBytes);
+        const fd  = fs.openSync(absPath, 'r');
+        try {
+          fs.readSync(fd, buf, 0, newBytes, state.size);
+        } finally {
+          fs.closeSync(fd);
         }
-      }, CHUNK_DELAY);
+        state.size = newSize;
+
+        const newLines = buf.toString('utf8').split('\n').filter(Boolean);
+        state.lines.push(...newLines);
+
+        clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+          const toSend = state.lines.splice(0);
+          if (toSend.length) {
+            const roomId = this.conn?.roomId || store.get('roomId') || '';
+            this.conn.emit('agent:logs', {
+              file:  absPath,
+              lines: toSend.map(l => ({ ts: Date.now(), text: encryptE2EE(l, roomId) })),
+            });
+          }
+        }, CHUNK_DELAY);
+      } catch (err) {
+        console.error(`[logs] Error reading log slice from ${absPath}:`, err.message);
+      }
     });
 
+
     watcher.on('error', (err) => {
       console.error(`[logs] Watch error on ${absPath}:`, err.message);
     });
@@ -107,12 +119,17 @@ class LogWatcher extends EventEmitter {
 
   _sendTail(filePath) {
     try {
-      const content = fs.readFileSync(filePath, 'utf8');
+      const absPath = filePath.startsWith('~')
+        ? path.join(process.env.HOME || '/', filePath.slice(1))
+        : path.resolve(filePath);
+      if (!fs.existsSync(absPath)) return;
+      const content = fs.readFileSync(absPath, 'utf8');
       const lines   = content.split('\n').filter(Boolean).slice(-BUFFER_LINES);
       if (lines.length) {
+        const roomId = this.conn?.roomId || store.get('roomId') || '';
         this.conn.emit('agent:logs:tail', {
           file:  filePath,
-          lines: lines.map(l => ({ ts: null, text: l })),
+          lines: lines.map(l => ({ ts: null, text: encryptE2EE(l, roomId) })),
         });
       }
     } catch (err) {

package/lib/metrics.js

@@ -2,25 +2,32 @@
 
 const si = require('systeminformation');
 
-const POLL_INTERVAL = 5000;
+const DEFAULT_POLL_INTERVAL = 1000;
 
 class MetricsPoller {
-  constructor({ connection, gpu = false, onMetricsEmit = null }) {
+  constructor({ connection, gpu = false, interval = DEFAULT_POLL_INTERVAL, onMetricsEmit = null }) {
     this.conn          = connection;
     this.gpu           = gpu;
+    this.interval      = Math.max(500, interval || DEFAULT_POLL_INTERVAL);
     this.onMetricsEmit = onMetricsEmit;  // alert engine callback — no monkey-patch needed
     this._timer        = null;
+    this._isPolling    = false;
     this._history      = [];
   }
 
   start() {
     this._poll();
-    this._timer = setInterval(() => this._poll(), POLL_INTERVAL);
-    console.log('[metrics] Poller started');
+    this._timer = setInterval(() => {
+      if (!this._isPolling) {
+        this._poll();
+      }
+    }, this.interval);
+    console.log(`[metrics] Poller started (interval: ${this.interval}ms)`);
   }
 
   stop() {
     if (this._timer) clearInterval(this._timer);
+    this._timer = null;
     console.log('[metrics] Poller stopped');
   }
 
@@ -29,6 +36,8 @@ class MetricsPoller {
   }
 
   async _poll() {
+    if (this._isPolling) return;
+    this._isPolling = true;
     try {
       const [cpu, mem, disk, net, procs] = await Promise.all([
         si.currentLoad(),
@@ -119,6 +128,62 @@ class MetricsPoller {
         }
       }
 
+      // ─── Automated Spike Diagnostic & Root Cause Engine ────────────────────────
+      const curCpuUsage = parseFloat(cpu.currentLoad.toFixed(1));
+      const curMemPct   = parseFloat(((mem.used / mem.total) * 100).toFixed(1));
+      const sortedProcs = (procs.list || []).slice().sort((a, b) => (b.pmem || 0) - (a.pmem || 0));
+      const topMemProc  = sortedProcs[0] || null;
+      const topCpuProc  = (procs.list || []).slice().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;
+
+      if (curMemPct >= 80 || memDelta >= 3.5) {
+        diagnostics.hasSpike = true;
+        diagnostics.type = 'memory';
+        diagnostics.deltaPct = memDelta;
+        if (topMemProc) {
+          const procMemMB = Math.round(((topMemProc.pmem || 0) / 100) * (mem.total / (1024 * 1024)));
+          diagnostics.culprit = {
+            pid: topMemProc.pid,
+            name: topMemProc.name,
+            command: topMemProc.command ? topMemProc.command.slice(0, 80) : topMemProc.name,
+            memPct: parseFloat((topMemProc.pmem || 0).toFixed(1)),
+            memMB: procMemMB,
+            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 ${diagnostics.culprit.memPct}% (${procMemMB} MB). Probable cause: Rapid memory allocation, large dataset buffer in memory, or memory leak.`;
+        }
+      } else if (curCpuUsage >= 80 || cpuDelta >= 25.0) {
+        diagnostics.hasSpike = true;
+        diagnostics.type = 'cpu';
+        diagnostics.deltaPct = cpuDelta;
+        if (topCpuProc) {
+          diagnostics.culprit = {
+            pid: topCpuProc.pid,
+            name: topCpuProc.name,
+            command: topCpuProc.command ? topCpuProc.command.slice(0, 80) : topCpuProc.name,
+            cpu: parseFloat((topCpuProc.pcpu || 0).toFixed(1)),
+            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 ${diagnostics.culprit.cpu}% CPU. Probable cause: Intensive computation, complex query/loop execution, or heavy background processing.`;
+        }
+      }
+
+      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;
@@ -129,6 +194,8 @@ class MetricsPoller {
 
     } catch (err) {
       console.error('[metrics] Poll error:', err.message);
+    } finally {
+      this._isPolling = false;
     }
   }
 }

package/lib/shell.js

@@ -11,6 +11,7 @@ try {
 const PTY_ENV_ALLOWLIST = new Set([
   'PATH', 'HOME', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'LC_CTYPE',
   'USER', 'LOGNAME', 'HOSTNAME', 'TZ', 'COLORTERM', 'DISPLAY',
+  'NVM_DIR', 'NODE_PATH', 'PM2_HOME', 'EDITOR', 'VISUAL', 'CI'
 ]);
 
 function buildSafeEnv() {
@@ -18,6 +19,19 @@ function buildSafeEnv() {
   for (const key of PTY_ENV_ALLOWLIST) {
     if (process.env[key] !== undefined) safe[key] = process.env[key];
   }
+  const home = process.env.HOME || '/home/ubuntu';
+  const extraPaths = [
+    `${home}/.nvm/versions/node/$(ls ${home}/.nvm/versions/node 2>/dev/null | tail -n 1)/bin`,
+    `${home}/.npm-global/bin`,
+    `${home}/.local/bin`,
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin'
+  ].join(':');
+
+  safe.PATH               = safe.PATH ? `${safe.PATH}:${extraPaths}` : extraPaths;
   safe.TERM               = 'xterm-256color';
   safe.THINKNCOLLAB_AGENT = '1';
   return safe;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "thinknagent",
-  "version": "0.1.20",
-  "description": "ThinkNCollab server agent — metrics, logs, alerts, shell bridge",
+  "version": "0.1.23",
+  "description": "ThinkNCollab server agent & MCP server — metrics, logs, alerts, shell bridge, AI planning",
   "main": "lib/agent.js",
   "author": "ThinkNCollab Team <raman@thinkncollab.com>",
   "bin": {
-    "thinknagent": "bin/thinknagent.js"
+    "thinknagent": "bin/thinknagent.js",
+    "thinkncollab-mcp": "bin/thinkncollab-mcp.js"
   },
   "scripts": {
     "start": "node bin/thinknagent.js start",

package/install/setup.sh

@@ -1,90 +0,0 @@
-#!/usr/bin/env bash
-# ThinkNCollab Agent — installer
-# Usage: curl -fsSL https://thinkncollab.com/install-agent.sh | bash -s -- --server https://thinkncollab.com --name my-server --room <roomId>
-set -euo pipefail
-
-SERVER=""
-NAME=""
-ROOM=""
-GPU=false
-LOGS=""
-SYSTEMD=false
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --server)  SERVER="$2"; shift 2 ;;
-    --name)    NAME="$2";   shift 2 ;;
-    --room)    ROOM="$2";   shift 2 ;;
-    --gpu)     GPU=true;    shift   ;;
-    --logs)    LOGS="$2";   shift 2 ;;
-    --systemd) SYSTEMD=true; shift  ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-[[ -z "$SERVER" ]] && echo "Error: --server required" && exit 1
-[[ -z "$NAME"   ]] && echo "Error: --name required"   && exit 1
-[[ -z "$ROOM"   ]] && echo "Error: --room required"   && exit 1
-
-echo ""
-echo "  ThinkNCollab Agent Installer"
-echo "  ──────────────────────────────"
-
-NODE_VER=$(node --version 2>/dev/null | cut -d. -f1 | tr -d 'v' || echo "0")
-if [[ "$NODE_VER" -lt 18 ]]; then
-  echo "  Error: Node.js 18+ required (found: $(node --version 2>/dev/null || echo 'not found'))"
-  exit 1
-fi
-echo "  Node.js : $(node --version) ✓"
-
-echo "  Installing thinknagent..."
-npm install -g thinknagent --silent
-
-GPU_FLAG=""
-$GPU && GPU_FLAG="--gpu"
-
-LOGS_FLAG=""
-[[ -n "$LOGS" ]] && LOGS_FLAG="--logs $LOGS"
-
-thinknagent init --server "$SERVER" --name "$NAME" --room "$ROOM" $GPU_FLAG $LOGS_FLAG
-
-if $SYSTEMD; then
-  echo ""
-  echo "  Setting up systemd service..."
-  id thinknagent &>/dev/null || useradd --system --no-create-home thinknagent
-  AGENT_BIN="$(which thinknagent)"
-  cat > /etc/systemd/system/thinknagent.service << SVCEOF
-[Unit]
-Description=ThinkNCollab Agent
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-User=thinknagent
-Group=thinknagent
-ExecStart=${AGENT_BIN} start
-Restart=on-failure
-RestartSec=10
-Environment=NODE_ENV=production
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=thinknagent
-
-[Install]
-WantedBy=multi-user.target
-SVCEOF
-  systemctl daemon-reload
-  systemctl enable thinknagent
-  systemctl start  thinknagent
-  echo "  systemd service: enabled + started ✓"
-  echo "  Logs: journalctl -u thinknagent -f"
-else
-  echo ""
-  echo "  To start now    : thinknagent start"
-  echo "  To run on boot  : Re-run this script with --systemd flag"
-  echo "  Or with pm2     : pm2 start \$(which thinknagent) -- start && pm2 save"
-fi
-
-echo ""
-echo "  ✓ Done. Open ThinkNCollab and approve this agent in your room's DevOps Wall."
-echo ""