thinknagent 0.1.31 → 0.1.34

package/lib/alerts.js

@@ -15,14 +15,21 @@
  * "for" = seconds the condition must persist before firing (0 = fire immediately)
  */
 
+const DEFAULT_ALERT_RULES = [
+  { id: 'cpu-high',  metric: 'cpu.usage',      op: 'gt', value: 85, for: 30, severity: 'warning' },
+  { id: 'cpu-crit',  metric: 'cpu.usage',      op: 'gt', value: 95, for: 15, severity: 'critical' },
+  { id: 'mem-high',  metric: 'memory.usedPct', op: 'gt', value: 90, for: 30, severity: 'warning' },
+  { id: 'disk-root', metric: 'disk./',         op: 'gt', value: 90, for: 0,  severity: 'critical' },
+];
+
 class AlertEngine {
   constructor({ connection, rules = [] }) {
     this.conn  = connection;
-    this.rules = rules;
+    this.rules = (rules && rules.length > 0) ? rules : DEFAULT_ALERT_RULES;
 
     // per-rule state: { firstTriggeredAt, fired }
     this._state = {};
-    for (const r of rules) {
+    for (const r of this.rules) {
       this._state[r.id] = { firstTriggeredAt: null, fired: false };
     }
   }

package/lib/metrics.js

@@ -236,21 +236,25 @@ class MetricsPoller {
       // pehle alert engine aur history ko raw metrics pass karo — 24/7 Edge evaluation
       this.onMetricsEmit?.(payload);
 
-      // MITM / Zero-Knowledge Defense: Encrypt metrics before sending over socket
+      // Military-grade AES-256-GCM End-to-End Encryption (E2EE)
       const store = require('./store');
       const { encryptE2EE } = require('./e2ee');
       const roomId = this.conn?.roomId || store.get('roomId');
+      const agentId = this.conn?.agentId || store.get('agentId');
 
       if (roomId) {
         const encrypted = encryptE2EE(payload, roomId);
         this.conn.emit('agent:metrics', {
-          agentId: this.conn.agentId || store.get('agentId'),
+          agentId,
           ts: payload.ts,
           encrypted,
           e2ee: true
         });
       } else {
-        this.conn.emit('agent:metrics', payload);
+        this.conn.emit('agent:metrics', {
+          agentId,
+          ...payload
+        });
       }
 
     } catch (err) {

package/lib/shell.js

@@ -1,12 +1,34 @@
 'use strict';
 
-let pty;
+let pty = null;
 try {
   pty = require('node-pty');
 } catch {
   pty = null;
 }
 
+let detectedPtyLauncher = null;
+function getPtyLauncher() {
+  if (detectedPtyLauncher) return detectedPtyLauncher;
+  if (pty) {
+    detectedPtyLauncher = 'node-pty';
+    return 'node-pty';
+  }
+  const { execSync } = require('child_process');
+  try {
+    execSync('python3 -c "import pty"', { stdio: 'ignore' });
+    detectedPtyLauncher = 'python3';
+    return 'python3';
+  } catch {}
+  try {
+    execSync('python -c "import pty"', { stdio: 'ignore' });
+    detectedPtyLauncher = 'python';
+    return 'python';
+  } catch {}
+  detectedPtyLauncher = 'spawn';
+  return 'spawn';
+}
+
 // 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',
@@ -61,16 +83,22 @@ class ShellBridge {
         this._sessions.delete(id);
       }
 
-      if (pty) {
-        const proc = pty.spawn(process.env.SHELL || '/bin/bash', [], {
+      const launcher = getPtyLauncher();
+      const shellPath = process.env.SHELL || '/bin/bash';
+      const homeDir = process.env.HOME || '/';
+      const safeEnv = buildSafeEnv();
+
+      if (launcher === 'node-pty' && pty) {
+        // Tier 1: node-pty native module
+        const proc = pty.spawn(shellPath, [], {
           name: 'xterm-256color',
           cols,
           rows,
-          cwd: process.env.HOME || '/',
-          env: buildSafeEnv(),
+          cwd: homeDir,
+          env: safeEnv,
         });
 
-        proc.onData(data => s.emit('shell:data', { sessionId, data }));
+        proc.onData(data => this._sendData(s, sessionId, data));
         proc.onExit(({ exitCode }) => {
           s.emit('shell:exit', { sessionId, exitCode });
           this._sessions.delete(sessionId);
@@ -79,18 +107,57 @@ class ShellBridge {
 
         this._sessions.set(sessionId, proc);
         s.emit('shell:opened', { sessionId });
-        console.log(`[shell] PTY session ${sessionId} opened (${cols}x${rows})`);
+        console.log(`[shell] PTY session ${sessionId} opened via node-pty (${cols}x${rows})`);
+      } else if (launcher === 'python3' || launcher === 'python') {
+        // Tier 2: Native OS pseudo-terminal via standard library pty.spawn
+        // Eliminates 'Inappropriate ioctl for device' & 'no job control' completely
+        const { spawn } = require('child_process');
+        const pyCode = 'import pty, os; os.environ["TERM"]="xterm-256color"; pty.spawn([os.environ.get("SHELL", "/bin/bash")])';
+        const proc = spawn(launcher, ['-c', pyCode], {
+          cwd: homeDir,
+          env: safeEnv,
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        proc.stdout.on('data', data => this._sendData(s, sessionId, data.toString()));
+        proc.stderr.on('data', data => {
+          const clean = data.toString()
+            .replace(/^bash: cannot set terminal process group.*?\n/gm, '')
+            .replace(/^bash: no job control in this shell.*?\n/gm, '');
+          if (clean) this._sendData(s, sessionId, clean);
+        });
+        proc.on('exit', exitCode => {
+          s.emit('shell:exit', { sessionId, exitCode: exitCode || 0 });
+          this._sessions.delete(sessionId);
+          console.log(`[shell] Python PTY session ${sessionId} exited (code ${exitCode})`);
+        });
+
+        this._sessions.set(sessionId, {
+          write: data => proc.stdin.write(data),
+          resize: () => {},
+          kill: () => {
+            try { proc.kill('SIGTERM'); } catch {}
+          }
+        });
+        s.emit('shell:opened', { sessionId });
+        console.log(`[shell] Genuine OS PTY session ${sessionId} opened via ${launcher}`);
       } else {
-        // Fallback to interactive standard child_process spawn
+        // Tier 3: Pure ChildProcess fallback with suppressed ioctl noise
         const { spawn } = require('child_process');
-        const proc = spawn(process.env.SHELL || '/bin/bash', ['-i'], {
-          cwd: process.env.HOME || '/',
-          env: buildSafeEnv(),
+        const proc = spawn(shellPath, ['--login'], {
+          cwd: homeDir,
+          env: safeEnv,
           stdio: ['pipe', 'pipe', 'pipe']
         });
 
-        proc.stdout.on('data', data => s.emit('shell:data', { sessionId, data: data.toString() }));
-        proc.stderr.on('data', data => s.emit('shell:data', { sessionId, data: data.toString() }));
+        proc.stdout.on('data', data => this._sendData(s, sessionId, data.toString()));
+        proc.stderr.on('data', data => {
+          // Filter out terminal ioctl startup noise on non-tty pipes
+          const clean = data.toString()
+            .replace(/^bash: cannot set terminal process group.*?\n/gm, '')
+            .replace(/^bash: no job control in this shell.*?\n/gm, '');
+          if (clean) this._sendData(s, sessionId, clean);
+        });
         proc.on('exit', exitCode => {
           s.emit('shell:exit', { sessionId, exitCode: exitCode || 0 });
           this._sessions.delete(sessionId);
@@ -99,17 +166,28 @@ class ShellBridge {
         this._sessions.set(sessionId, {
           write: data => proc.stdin.write(data),
           resize: () => {},
-          kill: () => proc.kill()
+          kill: () => {
+            try { proc.kill('SIGTERM'); } catch {}
+          }
         });
         s.emit('shell:opened', { sessionId });
-        console.log(`[shell] Interactive Spawn session ${sessionId} opened`);
+        console.log(`[shell] Fallback login shell session ${sessionId} opened`);
       }
     });
 
-    s.on('shell:input', ({ sessionId, data }) => {
+    s.on('shell:input', ({ sessionId, data, e2ee }) => {
       const proc = this._sessions.get(sessionId);
       if (!proc) return;
-      proc.write(data);
+      let text = data;
+      if (e2ee || (typeof data === 'string' && data.startsWith('e2ee:'))) {
+        const store = require('./store');
+        const { decryptE2EE } = require('./e2ee');
+        const roomId = this.conn?.roomId || store.get('roomId');
+        if (roomId) {
+          text = decryptE2EE(data, roomId);
+        }
+      }
+      proc.write(text);
     });
 
     s.on('shell:resize', ({ sessionId, cols, rows }) => {
@@ -132,6 +210,19 @@ class ShellBridge {
     }
   }
 
+  _sendData(s, sessionId, rawChunk) {
+    if (!rawChunk) return;
+    const store = require('./store');
+    const { encryptE2EE } = require('./e2ee');
+    const roomId = this.conn?.roomId || store.get('roomId');
+    if (roomId) {
+      const encrypted = encryptE2EE(rawChunk, roomId);
+      s.emit('shell:data', { sessionId, data: encrypted, e2ee: true });
+    } else {
+      s.emit('shell:data', { sessionId, data: rawChunk, e2ee: false });
+    }
+  }
+
   killAll() {
     for (const [id] of this._sessions) this._killSession(id);
   }

package/package.json

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