thinknagent 0.1.10 → 0.1.12

package/Readme.md

@@ -181,6 +181,17 @@ Role is assigned by the room Owner at approval time and can be changed anytime f
 
 ---
 
+## Security & Privacy
+
+The agent is designed with a "zero-trust" approach to protect your server's credentials, logs, and shell sessions.
+
+- 🔒 **Double-Gate Authorization**: New agents connect in `PENDING` mode. They cannot stream metrics or logs until explicitly approved by the room Owner. Upon approval, they receive a signed HMAC `agentToken` for secure reconnection.
+- 🛡️ **Remote Shell Environment Insulation**: Spawning a shell strips all server environment variables, passing only a safe allowlist (`PATH`, `HOME`, `SHELL`, `TERM`, `LANG`). Your database credentials, cloud API keys, and environment secrets remain completely safe.
+- 🚫 **Path Traversal & Sensitive File Blocks**: Log files are verified using absolute path checking. They must belong to allowed directories (`/var/log`, `/home`, `/root`, `/tmp`) and are explicitly blocked if they contain sensitive directories or files like `.ssh/id_rsa`, `.env`, `/etc/passwd`, `/etc/shadow`, etc.
+- 💬 **SSL Transport**: All WebSocket and HTTP traffic between the agent and the server is encrypted using HTTPS/WSS.
+
+---
+
 ## Auth Flow
 thinknagent init
 → generates agentId
@@ -241,7 +252,7 @@ pm2 startup
 
 **Using systemd:**
 ```bash
-sudo nano /etc/systemd/system/app.service
+sudo nano /etc/systemd/system/thinknagent.service
 ```
 
 ```ini

package/install/setup.sh

@@ -1,35 +1,35 @@
 #!/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
-
+# 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
 
-# Parse args
 while [[ $# -gt 0 ]]; do
   case $1 in
-    --server) SERVER="$2"; shift 2 ;;
-    --name)   NAME="$2";   shift 2 ;;
-    --gpu)    GPU=true;    shift   ;;
-    --logs)   LOGS="$2";   shift 2 ;;
-    --systemd) SYSTEMD=true; shift ;;
+    --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 "  ──────────────────────────────"
 
-# Check Node.js >= 18
 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'))"
@@ -37,34 +37,45 @@ if [[ "$NODE_VER" -lt 18 ]]; then
 fi
 echo "  Node.js : $(node --version) ✓"
 
-# Install package
 echo "  Installing thinknagent..."
 npm install -g thinknagent --silent
 
-# Init
 GPU_FLAG=""
 $GPU && GPU_FLAG="--gpu"
+
 LOGS_FLAG=""
 [[ -n "$LOGS" ]] && LOGS_FLAG="--logs $LOGS"
 
-thinknagent init --server "$SERVER" --name "$NAME" $GPU_FLAG $LOGS_FLAG
+thinknagent init --server "$SERVER" --name "$NAME" --room "$ROOM" $GPU_FLAG $LOGS_FLAG
 
-# Optional systemd setup
 if $SYSTEMD; then
   echo ""
   echo "  Setting up systemd service..."
-
-  # Create system user
   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
 
-  # Copy service file
-  AGENT_SERVICE_SRC="$(npm root -g)/thinknagent/install/thinknagent.service"
-  cp "$AGENT_SERVICE_SRC" /etc/systemd/system/thinknagent.service
+[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
@@ -76,4 +87,4 @@ fi
 
 echo ""
 echo "  ✓ Done. Open ThinkNCollab and approve this agent in your room's DevOps Wall."
-echo ""
+echo ""

package/install/thinknagent.service

@@ -5,31 +5,21 @@ After=network-online.target
 Wants=network-online.target
 
 [Service]
-# Run as a dedicated low-privilege user for security
-# Create with: sudo useradd --system --no-create-home thinknagent
 User=thinknagent
 Group=thinknagent
-
-# Point to wherever thinknagent was installed globally
-ExecStart=/usr/bin/node /usr/local/bin/thinknagent start
-
-# Restart policy
+ExecStart=/usr/bin/env thinknagent start
 Restart=on-failure
 RestartSec=10
 StartLimitInterval=60
 StartLimitBurst=3
 
-# Hardening — limit what the process can do
 NoNewPrivileges=true
 ProtectSystem=strict
-ProtectHome=read-only        # needed to read ~/.thinknagent/config.json
-ReadWritePaths=/root/.thinknagent /home/%u/.thinknagent
-PrivateTmp=true
+ProtectHome=false
+ReadWritePaths=%h/.thinknagent
 
-# Environment
+PrivateTmp=true
 Environment=NODE_ENV=production
-
-# Logging — journald will capture stdout/stderr
 StandardOutput=journal
 StandardError=journal
 SyslogIdentifier=thinknagent

package/lib/agent.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const path          = require('path');
 const Connection    = require('./connect');
 const MetricsPoller = require('./metrics');
 const LogWatcher    = require('./logwatcher');
@@ -7,102 +8,140 @@ const AlertEngine   = require('./alerts');
 const ShellBridge   = require('./shell');
 const store         = require('./store');
 
+// allowed base dirs for log streaming
+// room owner agent:logs_updated se bahar ke paths reject ho jayenge
+const LOG_PATH_ALLOWLIST = [
+  '/var/log',
+  '/home',
+  '/root',
+  '/tmp',
+];
+
+function isSafeLogPath(logPath) {
+  const resolved = path.resolve(logPath);
+
+  // path traversal check — resolved path allowlist mein hona chahiye
+  const allowed = LOG_PATH_ALLOWLIST.some(base => resolved.startsWith(base + path.sep) || resolved === base);
+  if (!allowed) {
+    console.warn(`[agent] Rejected log path (not in allowlist): ${resolved}`);
+    return false;
+  }
+
+  // sensitive files blocklist
+  const BLOCKED = [
+    '/etc/passwd', '/etc/shadow', '/etc/sudoers',
+    '.ssh', '.gnupg', '.aws', '.env',
+    'id_rsa', 'id_ed25519', 'authorized_keys',
+  ];
+  const blocked = BLOCKED.some(b => resolved.includes(b));
+  if (blocked) {
+    console.warn(`[agent] Rejected sensitive log path: ${resolved}`);
+    return false;
+  }
+
+  return true;
+}
+
+function validateRules(rules) {
+  if (!Array.isArray(rules)) return [];
+  return rules.filter(r =>
+    r && typeof r.id === 'string' &&
+    typeof r.metric === 'string' &&
+    typeof r.op === 'string' &&
+    typeof r.value === 'number'
+  );
+}
+
 class Agent {
   constructor() {
     const cfg = store.read();
 
-    this.conn    = new Connection({
+    this.alerts = new AlertEngine({
+      connection: null,
+      rules:      cfg.alerts || [],
+    });
+
+    this.conn = new Connection({
       serverUrl:    cfg.serverUrl,
       onReady:      ({ role, roomId }) => this._onReady(role, roomId),
       onDisconnect: ({ reason })       => this._onDisconnect(reason),
       onRoleUpdate: ({ role })         => this._onRoleUpdate(role),
     });
 
-    this.metrics = new MetricsPoller({
-      connection: this.conn,
-      gpu:        cfg.gpu || false,
-    });
+    this.alerts.conn = this.conn;
 
-    this.logs    = new LogWatcher({
-      connection: this.conn,
-      logPaths:   cfg.logs || [],
+    this.metrics = new MetricsPoller({
+      connection:    this.conn,
+      gpu:           cfg.gpu || false,
+      onMetricsEmit: (payload) => this.alerts.evaluate(payload),
     });
 
-    this.alerts  = new AlertEngine({
+    this.logs  = new LogWatcher({
       connection: this.conn,
-      rules:      cfg.alerts || [],
+      logPaths:   (cfg.logs || []).filter(isSafeLogPath),
     });
 
     this.shell   = new ShellBridge({ connection: this.conn });
-
     this._active = false;
   }
 
-start() {
-  const cfg = store.read();
-  if (!cfg.serverUrl) {
-    console.error('[agent] Not initialized.');
-    process.exit(1);
-  }
+  start() {
+    const cfg = store.read();
+    if (!cfg.serverUrl) {
+      console.error('[agent] Not initialized.');
+      process.exit(1);
+    }
 
-  console.log(`[agent] Connecting to ${cfg.serverUrl}...`);
-  
-  // ✅ Pehle connect karo
-  this.conn.connect();
-
-  // ✅ Socket ready hone ke baad events bind karo
-  //    conn.socket ab available hai kyunki connect() sync mein socket banata hai
-  this.conn.socket.on('agent:rules_updated', ({ rules }) => {
-    store.set('alerts', rules);
-    this.alerts.reloadRules(rules);
-  });
-
-  this.conn.socket.on('agent:send_metrics_now', () => {
-    console.log('[agent] Metrics poll requested');
-    this.metrics.pollNow();
-  });
-
-  this.conn.socket.on('agent:logs_updated', ({ logs }) => {
-    store.set('logs', logs);
-    this.logs.stop();
-    this.logs = new LogWatcher({ connection: this.conn, logPaths: logs });
-    if (this._active) this.logs.start(); // ✅ sirf tab start karo agar active ho
-  });
+    console.log(`[agent] Connecting to ${cfg.serverUrl}...`);
+    this.conn.connect();
 
-  process.on('SIGTERM', () => this._shutdown('SIGTERM'));
-  process.on('SIGINT',  () => this._shutdown('SIGINT'));
-}
+    this.conn.socket.on('agent:rules_updated', ({ rules }) => {
+      const safe = validateRules(rules);
+      store.set('alerts', safe);
+      this.alerts.reloadRules(safe);
+    });
 
-_onReady(role, roomId) {
-  if (this._active) {
-    // Reconnect case — metrics/logs already chal rahe hain
-    console.log(`[agent] Reconnected. Role: ${role}`);
-    return;
-  }
+    this.conn.socket.on('agent:send_metrics_now', () => {
+      console.log('[agent] Metrics poll requested');
+      this.metrics.pollNow();
+    });
 
-  this._active = true;
-  console.log(`[agent] Active! Role: ${role} | Room: ${roomId}`);
+    this.conn.socket.on('agent:logs_updated', ({ logs }) => {
+      if (!Array.isArray(logs)) return;
 
-  // ✅ Metrics emit ko alert engine se connect karo
-  const origEmit = this.conn.emit.bind(this.conn);
-  this.conn.emit = (event, data) => {
-    if (event === 'agent:metrics') this.alerts.evaluate(data);
-    origEmit(event, data);
-  };
+      // har path validate karo — koi bhi unsafe ho toh poori update reject
+      const safeLogs = logs.filter(isSafeLogPath);
+      if (safeLogs.length !== logs.length) {
+        console.warn(`[agent] Dropped ${logs.length - safeLogs.length} unsafe log path(s) from server update`);
+      }
 
-  this.metrics.start();
-  this.logs.start();
-  this.shell.start();
-}
-  
+      store.set('logs', safeLogs);
+      this.logs.stop();
+      this.logs = new LogWatcher({ connection: this.conn, logPaths: safeLogs });
+      if (this._active) this.logs.start();
+    });
+
+    process.on('SIGTERM', () => this._shutdown('SIGTERM'));
+    process.on('SIGINT',  () => this._shutdown('SIGINT'));
+  }
+
+  _onReady(role, roomId) {
+    if (this._active) {
+      console.log(`[agent] Reconnected. Role: ${role}`);
+      return;
+    }
+    this._active = true;
+    console.log(`[agent] Active! Role: ${role} | Room: ${roomId}`);
+    this.metrics.start();
+    this.logs.start();
+    this.shell.start();
+  }
 
   _onDisconnect(reason) {
     this.shell.killAll();
-    // metrics + logs keep their intervals; socket.io will reconnect automatically
   }
 
   _onRoleUpdate({ role }) {
-    // If role was downgraded to 'monitor', kill open shell sessions
     if (!this.conn.hasRole('shell')) {
       this.shell.killAll();
     }
@@ -118,4 +157,4 @@ _onReady(role, roomId) {
   }
 }
 
-module.exports = Agent;
+module.exports = Agent;

package/lib/logwatcher.js

@@ -2,17 +2,18 @@
 
 const fs      = require('fs');
 const path    = require('path');
+const chokidar = require('chokidar');
 const { EventEmitter } = require('events');
 
-const BUFFER_LINES = 100;   // lines to send on initial connect
-const CHUNK_DELAY  = 50;    // ms debounce before flushing new lines
+const BUFFER_LINES = 100;
+const CHUNK_DELAY  = 50;
 
 class LogWatcher extends EventEmitter {
   constructor({ connection, logPaths = [] }) {
     super();
     this.conn     = connection;
     this.logPaths = logPaths;
-    this._watchers = new Map(); // path → { fd, size, timer }
+    this._watchers = new Map(); // path → { watcher, size, timer, lines }
   }
 
   start() {
@@ -27,8 +28,8 @@ class LogWatcher extends EventEmitter {
   }
 
   stop() {
-    for (const [p, w] of this._watchers) {
-      try { fs.unwatchFile(p); } catch {}
+    for (const [, w] of this._watchers) {
+      w.watcher.close();
       if (w.timer) clearTimeout(w.timer);
     }
     this._watchers.clear();
@@ -37,43 +38,51 @@ class LogWatcher extends EventEmitter {
   _watch(filePath) {
     const absPath = path.resolve(filePath);
 
-    if (!fs.existsSync(absPath)) {
-      console.warn(`[logs] File not found: ${absPath} — will retry when it appears`);
-      // retry every 10s in case log file is created later
-      setTimeout(() => this._watch(filePath), 10000);
-      return;
-    }
-
-    const stat = fs.statSync(absPath);
     const state = {
-      size:  stat.size,
-      timer: null,
-      lines: [],
+      watcher: null,
+      size:    fs.existsSync(absPath) ? fs.statSync(absPath).size : 0,
+      timer:   null,
+      lines:   [],
     };
 
-    // Send last BUFFER_LINES lines on startup
-    this._sendTail(absPath);
+    // send tail on startup if file exists
+    if (fs.existsSync(absPath)) {
+      this._sendTail(absPath);
+    }
+
+    const watcher = chokidar.watch(absPath, {
+      persistent:    true,
+      usePolling:    false,   // inotify on Linux — no polling overhead
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 50 },
+    });
 
-    fs.watchFile(absPath, { interval: 500 }, (curr, prev) => {
-      if (curr.size < prev.size) {
-        // Log rotated — reset position
+    watcher.on('add', () => {
+      // file created after watch started (e.g. log rotation)
+      state.size = 0;
+      this._sendTail(absPath);
+    });
+
+    watcher.on('change', (fpath, stats) => {
+      const newSize = stats ? stats.size : fs.statSync(absPath).size;
+
+      if (newSize < state.size) {
+        // log rotated — reset
         state.size = 0;
       }
-      if (curr.size === prev.size) return;
 
-      const newBytes = curr.size - state.size;
+      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 = curr.size;
+      state.size = newSize;
 
       const newLines = buf.toString('utf8').split('\n').filter(Boolean);
       state.lines.push(...newLines);
 
-      // debounce — batch lines before emit
       clearTimeout(state.timer);
       state.timer = setTimeout(() => {
         const toSend = state.lines.splice(0);
@@ -86,6 +95,11 @@ class LogWatcher extends EventEmitter {
       }, CHUNK_DELAY);
     });
 
+    watcher.on('error', (err) => {
+      console.error(`[logs] Watch error on ${absPath}:`, err.message);
+    });
+
+    state.watcher = watcher;
     this._watchers.set(absPath, state);
   }
 
@@ -96,7 +110,7 @@ class LogWatcher extends EventEmitter {
       if (lines.length) {
         this.conn.emit('agent:logs:tail', {
           file:  filePath,
-          lines: lines.map(l => ({ ts: null, text: l })), // historical = no ts
+          lines: lines.map(l => ({ ts: null, text: l })),
         });
       }
     } catch (err) {
@@ -105,4 +119,4 @@ class LogWatcher extends EventEmitter {
   }
 }
 
-module.exports = LogWatcher;
+module.exports = LogWatcher;

package/lib/metrics.js

@@ -2,18 +2,19 @@
 
 const si = require('systeminformation');
 
-const POLL_INTERVAL = 5000; // ms
+const POLL_INTERVAL = 5000;
 
 class MetricsPoller {
-  constructor({ connection, gpu = false }) {
-    this.conn     = connection;
-    this.gpu      = gpu;
-    this._timer   = null;
-    this._history = []; // last 60 data points (5 min rolling)
+  constructor({ connection, gpu = false, onMetricsEmit = null }) {
+    this.conn          = connection;
+    this.gpu           = gpu;
+    this.onMetricsEmit = onMetricsEmit;  // alert engine callback — no monkey-patch needed
+    this._timer        = null;
+    this._history      = [];
   }
 
   start() {
-    this._poll(); // immediate first poll
+    this._poll();
     this._timer = setInterval(() => this._poll(), POLL_INTERVAL);
     console.log('[metrics] Poller started');
   }
@@ -22,50 +23,49 @@ class MetricsPoller {
     if (this._timer) clearInterval(this._timer);
     console.log('[metrics] Poller stopped');
   }
+
   pollNow() {
-  return this._poll();
-}
+    return this._poll();
+  }
 
   async _poll() {
     try {
-      const [cpu, mem, disk, net, load, procs] = await Promise.all([
+      const [cpu, mem, disk, net, procs] = await Promise.all([
         si.currentLoad(),
         si.mem(),
         si.fsSize(),
         si.networkStats(),
-        si.currentLoad(),       // for load average
         si.processes(),
       ]);
 
       const payload = {
         ts: Date.now(),
         cpu: {
-          usage:    parseFloat(cpu.currentLoad.toFixed(1)),
-          cores:    cpu.cpus?.length ?? 0,
-          loadAvg:  load.avgLoad ?? 0,
+          usage:   parseFloat(cpu.currentLoad.toFixed(1)),
+          cores:   cpu.cpus?.length ?? 0,
+          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,
+          used:    mem.used,
+          free:    mem.free,
+          usedPct: parseFloat(((mem.used / mem.total) * 100).toFixed(1)),
         },
         disk: disk.map(d => ({
-          fs:       d.fs,
-          mount:    d.mount,
-          size:     d.size,
-          used:     d.used,
-          usedPct:  parseFloat(d.use?.toFixed(1) ?? 0),
+          fs:      d.fs,
+          mount:   d.mount,
+          size:    d.size,
+          used:    d.used,
+          usedPct: parseFloat(d.use?.toFixed(1) ?? 0),
         })),
         network: net.map(n => ({
-          iface:    n.iface,
-          rxSec:    n.rx_sec ?? 0,
-          txSec:    n.tx_sec ?? 0,
+          iface: n.iface,
+          rxSec: n.rx_sec ?? 0,
+          txSec: n.tx_sec ?? 0,
         })),
         processes: {
-          total:  procs.all,
+          total:   procs.all,
           running: procs.running,
-          // top 5 by CPU
           top: (procs.list || [])
             .sort((a, b) => b.pcpu - a.pcpu)
             .slice(0, 5)
@@ -73,33 +73,33 @@ class MetricsPoller {
         },
       };
 
-      // optional GPU
       if (this.gpu) {
         try {
           const gpuData = await si.graphics();
           payload.gpu = gpuData.controllers?.map(g => ({
-            model:      g.model,
+            model:          g.model,
             utilizationGpu: g.utilizationGpu ?? null,
-            memUsed:    g.memoryUsed ?? null,
-            memTotal:   g.memoryTotal ?? null,
-            tempC:      g.temperatureGpu ?? null,
+            memUsed:        g.memoryUsed ?? null,
+            memTotal:       g.memoryTotal ?? null,
+            tempC:          g.temperatureGpu ?? null,
           }));
         } catch {
           // nvidia-smi not available — silently skip
         }
       }
 
-      // rolling history (keep last 60 points)
       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;
 
+      // pehle emit karo, phir alert engine ko directly pass karo — no interception
       this.conn.emit('agent:metrics', payload);
+      this.onMetricsEmit?.(payload);
+
     } catch (err) {
       console.error('[metrics] Poll error:', err.message);
     }
   }
 }
 
-module.exports = MetricsPoller;
+module.exports = MetricsPoller;

package/lib/shell.js

@@ -4,54 +4,65 @@ let pty;
 try {
   pty = require('node-pty');
 } catch {
-  pty = null; // node-pty is optional — shell feature disabled if not installed
+  pty = null;
 }
 
-/**
- * Shell bridge — opens a PTY session on this server and relays I/O
- * bidirectionally over Socket.IO to the DevOps Wall xterm.js terminal.
- *
- * Role gate: connection.hasRole('shell') must be true.
- * If the agent role is 'monitor' only, all shell:open events are rejected.
- */
+// explicit allowlist — agent process ke secrets PTY mein nahi jayenge
+const PTY_ENV_ALLOWLIST = new Set([
+  'PATH', 'HOME', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'LC_CTYPE',
+  'USER', 'LOGNAME', 'HOSTNAME', 'TZ', 'COLORTERM', 'DISPLAY',
+]);
+
+function buildSafeEnv() {
+  const safe = {};
+  for (const key of PTY_ENV_ALLOWLIST) {
+    if (process.env[key] !== undefined) safe[key] = process.env[key];
+  }
+  safe.TERM               = 'xterm-256color';
+  safe.THINKNCOLLAB_AGENT = '1';
+  return safe;
+}
 
 class ShellBridge {
   constructor({ connection }) {
-    this.conn     = connection;
-    this._sessions = new Map(); // sessionId → ptyProcess
+    this.conn      = connection;
+    this._sessions = new Map();
   }
 
   start() {
+    const s = this.conn.socket;
+
     if (!pty) {
       console.warn('[shell] node-pty not installed — shell feature disabled');
+      s.on('shell:open', ({ sessionId }) => {
+        s.emit('shell:error', {
+          sessionId,
+          reason: 'node-pty is not installed on this agent. Run: npm install -g node-pty',
+        });
+      });
       return;
     }
 
-    const s = this.conn.socket;
-
-    // Browser requests a new shell session
     s.on('shell:open', ({ sessionId, cols = 80, rows = 24 }) => {
       if (!this.conn.hasRole('shell')) {
-        s.emit('shell:error', { sessionId, reason: 'Insufficient role — shell access not granted for this agent' });
+        s.emit('shell:error', {
+          sessionId,
+          reason: 'Insufficient role — shell access not granted for this agent',
+        });
         return;
       }
-      if (this._sessions.has(sessionId)) return; // already open
+
+      if (this._sessions.has(sessionId)) return;
 
       const proc = pty.spawn(process.env.SHELL || '/bin/bash', [], {
         name: 'xterm-256color',
         cols,
         rows,
-        cwd:  process.env.HOME || '/',
-        env:  {
-          ...process.env,
-          TERM: 'xterm-256color',
-          THINKNCOLLAB_AGENT: '1',       // agent can inject this env so shell scripts know
-        },
+        cwd: process.env.HOME || '/',
+        env: buildSafeEnv(),   // only allowlisted vars — no secrets
       });
 
-      proc.onData(data => {
-        s.emit('shell:data', { sessionId, data });
-      });
+      proc.onData(data => s.emit('shell:data', { sessionId, data }));
 
       proc.onExit(({ exitCode }) => {
         s.emit('shell:exit', { sessionId, exitCode });
@@ -64,24 +75,19 @@ class ShellBridge {
       console.log(`[shell] Session ${sessionId} opened (${cols}x${rows})`);
     });
 
-    // Browser → server → agent: user typed something
     s.on('shell:input', ({ sessionId, data }) => {
       const proc = this._sessions.get(sessionId);
       if (!proc) return;
       proc.write(data);
     });
 
-    // Browser resized terminal
     s.on('shell:resize', ({ sessionId, cols, rows }) => {
       const proc = this._sessions.get(sessionId);
       if (!proc) return;
       proc.resize(cols, rows);
     });
 
-    // Browser closed terminal tab
-    s.on('shell:close', ({ sessionId }) => {
-      this._killSession(sessionId);
-    });
+    s.on('shell:close', ({ sessionId }) => this._killSession(sessionId));
 
     console.log('[shell] Bridge ready');
   }
@@ -95,10 +101,9 @@ class ShellBridge {
     }
   }
 
-  // Kill all sessions on disconnect
   killAll() {
     for (const [id] of this._sessions) this._killSession(id);
   }
 }
 
-module.exports = ShellBridge;
+module.exports = ShellBridge;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "thinknagent",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "ThinkNCollab server agent — metrics, logs, alerts, shell bridge",
   "main": "lib/agent.js",
+  "author": "ThinkNCollab Team <team@thinkncollab.com>",
   "bin": {
     "thinknagent": "./bin/thinknagent.js"
   },