neoagent 2.4.4-beta.0 → 2.4.4-beta.4

package/server/services/cli/shell_worker.js

@@ -0,0 +1,135 @@
+/**
+ * shell_worker.js — Forked shell execution worker
+ *
+ * This file is intentionally self-contained with zero imports from server/.
+ * It runs as a child_process.fork() child with no access to the server's
+ * database, JWT secrets, or any app state. The blast radius of a compromised
+ * command result is limited to this process.
+ *
+ * Protocol (IPC):
+ *   Request:  { requestId, command, options: { cwd, timeout, env, stdinInput } }
+ *   Response: { requestId, result: { stdout, stderr, exitCode, timedOut, durationMs } }
+ *             | { requestId, error: string }
+ */
+'use strict';
+
+const { spawn, execFileSync } = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+const FORCE_KILL_GRACE_MS = 5000;
+const MAX_STDOUT_CHARS = 50000;
+const MAX_STDERR_CHARS = 10000;
+
+let _defaultShell = null;
+
+function resolveShell() {
+  if (_defaultShell) return _defaultShell;
+  const candidates = [process.env.SHELL, '/bin/zsh', '/bin/bash', '/bin/sh'].filter(Boolean);
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ['-lc', 'printf ok'], {
+        timeout: 3000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      _defaultShell = candidate;
+      return _defaultShell;
+    } catch {}
+  }
+  _defaultShell = '/bin/sh';
+  return _defaultShell;
+}
+
+function clampTimeout(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_TIMEOUT_MS;
+}
+
+function truncate(str, max) {
+  if (typeof str !== 'string') str = String(str ?? '');
+  return str.length > max ? str.slice(0, max) + `\n...[truncated, ${str.length} total chars]` : str;
+}
+
+function supportsPipefail(shell) {
+  return /(?:^|\/)(?:bash|zsh|ksh|mksh|yash)$/.test(String(shell || ''));
+}
+
+function execute(command, options, callback) {
+  const shell = resolveShell();
+  const cwd = options.cwd || process.env.HOME;
+  const timeout = clampTimeout(options.timeout);
+  const wrapped = supportsPipefail(shell) ? `set -o pipefail; ${command}` : command;
+
+  let stdout = '';
+  let stderr = '';
+  let killed = false;
+  let timedOut = false;
+  const startedAt = Date.now();
+
+  let env = { ...process.env };
+  if (options.env && typeof options.env === 'object') {
+    env = { ...env, ...options.env };
+  }
+
+  const proc = spawn(shell, ['-l', '-c', wrapped], {
+    cwd,
+    env,
+    detached: process.platform !== 'win32',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  const timer = setTimeout(() => {
+    killed = true;
+    timedOut = true;
+    try { process.kill(-proc.pid, 'SIGTERM'); } catch { proc.kill('SIGTERM'); }
+    setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, FORCE_KILL_GRACE_MS);
+  }, timeout);
+
+  proc.stdout.on('data', (d) => { stdout += d; if (stdout.length > 500000) stdout = stdout.slice(-250000); });
+  proc.stderr.on('data', (d) => { stderr += d; if (stderr.length > 100000) stderr = stderr.slice(-50000); });
+
+  if (options.stdinInput) {
+    proc.stdin.write(options.stdinInput);
+    proc.stdin.end();
+  }
+
+  proc.on('close', (code) => {
+    clearTimeout(timer);
+    callback(null, {
+      exitCode: typeof code === 'number' ? code : null,
+      stdout: truncate(stdout.trim(), MAX_STDOUT_CHARS),
+      stderr: truncate(stderr.trim(), MAX_STDERR_CHARS),
+      killed,
+      timedOut,
+      durationMs: Date.now() - startedAt,
+      command,
+      cwd,
+    });
+  });
+
+  proc.on('error', (err) => {
+    clearTimeout(timer);
+    callback(null, {
+      exitCode: -1,
+      stdout: '',
+      stderr: err.message,
+      killed: false,
+      timedOut: false,
+      durationMs: Date.now() - startedAt,
+      command,
+      cwd,
+      error: err.message,
+    });
+  });
+}
+
+process.on('message', ({ requestId, command, options = {} }) => {
+  try {
+    execute(command, options, (err, result) => {
+      process.send({ requestId, result });
+    });
+  } catch (err) {
+    process.send({ requestId, error: String(err?.message || err) });
+  }
+});
+
+// Signal readiness
+process.send?.({ type: 'ready' });

package/server/services/cli/shell_worker_pool.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const { fork } = require('child_process');
+const { randomUUID } = require('crypto');
+const path = require('path');
+
+const WORKER_SCRIPT = path.resolve(__dirname, 'shell_worker.js');
+
+class ShellWorkerPool {
+  /**
+   * @param {object} [options]
+   * @param {number} [options.size=4]       Number of worker processes to keep alive
+   * @param {string} [options.workerScript] Override worker script path (for tests)
+   */
+  constructor({ size = 4, workerScript = WORKER_SCRIPT } = {}) {
+    this._size = size;
+    this._workerScript = workerScript;
+    /** @type {Array<{ proc: ChildProcess, busy: boolean, pendingRequestId: string|null }>} */
+    this._workers = [];
+    /** @type {Array<{ requestId: string, command: string, options: object, resolve: Function, reject: Function }>} */
+    this._queue = [];
+    /** @type {Map<string, Function>} requestId → resolve */
+    this._pending = new Map();
+
+    for (let i = 0; i < this._size; i++) {
+      this._spawnWorker();
+    }
+  }
+
+  _spawnWorker() {
+    const proc = fork(this._workerScript, [], {
+      detached: false,
+      stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+      env: { ...process.env },
+    });
+
+    const workerEntry = { proc, busy: false, pendingRequestId: null };
+    this._workers.push(workerEntry);
+
+    proc.on('message', (msg) => {
+      if (msg?.type === 'ready') return;
+
+      const { requestId, result, error } = msg || {};
+      const resolve = this._pending.get(requestId);
+      if (resolve) {
+        this._pending.delete(requestId);
+        resolve(error ? { exitCode: -1, stdout: '', stderr: error, killed: false, timedOut: false } : result);
+      }
+      workerEntry.busy = false;
+      workerEntry.pendingRequestId = null;
+      this._drain();
+    });
+
+    proc.on('exit', (code) => {
+      console.warn(`[ShellWorkerPool] Worker exited (code=${code}), respawning`);
+      const idx = this._workers.indexOf(workerEntry);
+      if (idx !== -1) this._workers.splice(idx, 1);
+
+      // Reject the in-flight request on this worker, if any
+      if (workerEntry.pendingRequestId) {
+        const resolve = this._pending.get(workerEntry.pendingRequestId);
+        if (resolve) {
+          this._pending.delete(workerEntry.pendingRequestId);
+          resolve({ exitCode: -1, stdout: '', stderr: 'Worker process crashed', killed: true, timedOut: false });
+        }
+      }
+
+      this._spawnWorker();
+    });
+
+    proc.on('error', (err) => {
+      console.error('[ShellWorkerPool] Worker error:', err.message);
+    });
+
+    return workerEntry;
+  }
+
+  _drain() {
+    if (this._queue.length === 0) return;
+    const idleWorker = this._workers.find((w) => !w.busy);
+    if (!idleWorker) return;
+
+    const job = this._queue.shift();
+    this._dispatch(idleWorker, job);
+  }
+
+  _dispatch(workerEntry, job) {
+    const { requestId, command, options, resolve } = job;
+    workerEntry.busy = true;
+    workerEntry.pendingRequestId = requestId;
+    this._pending.set(requestId, resolve);
+    workerEntry.proc.send({ requestId, command, options });
+  }
+
+  /**
+   * Execute a shell command in an isolated worker process.
+   * @param {string} command
+   * @param {object} [options]
+   * @returns {Promise<object>} result with { stdout, stderr, exitCode, killed, timedOut, durationMs }
+   */
+  execute(command, options = {}) {
+    return new Promise((resolve) => {
+      const requestId = randomUUID();
+      const job = { requestId, command, options, resolve };
+      const idleWorker = this._workers.find((w) => !w.busy);
+      if (idleWorker) {
+        this._dispatch(idleWorker, job);
+      } else {
+        this._queue.push(job);
+      }
+    });
+  }
+
+  /** Gracefully terminate all workers. */
+  shutdown() {
+    for (const w of this._workers) {
+      try { w.proc.kill(); } catch {}
+    }
+    this._workers = [];
+    this._queue = [];
+    this._pending.clear();
+  }
+}
+
+module.exports = { ShellWorkerPool };

package/server/services/manager.js

@@ -26,6 +26,9 @@ const { StructuredDataService } = require('./workspace/structured_data');
 const { TaskWebhookService } = require('./tasks/webhooks');
 const { LearningManager } = require('./ai/learning');
 const { CapabilityAuditService } = require('./security/capability_audit');
+const { ToolPolicyService } = require('./security/tool_policy_service');
+const { ApprovalGateService } = require('./security/approval_gate_service');
+const { registerToolSecurityHooks } = require('./security/tool_security_hook');
 const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
@@ -95,6 +98,7 @@ function createDesktopCompanionRegistry(app) {
 
 function createMemoryManager(app) {
   const memoryManager = registerLocal(app, 'memoryManager', new MemoryManager());
+  memoryManager.startEmbeddingIndexBackfill();
   const reconcile = () => {
     const users = db.prepare('SELECT id FROM users').all();
     for (const user of users) {
@@ -248,15 +252,23 @@ function createBrowserController(app, artifactStore) {
 }
 
 function createRuntimeManager(app) {
+  const { ShellWorkerPool } = require('./cli/shell_worker_pool');
+  const shellWorkerPool = registerLocal(
+    app,
+    'shellWorkerPool',
+    new ShellWorkerPool({ size: 4 }),
+  );
   const runtimeManager = registerLocal(
     app,
     'runtimeManager',
     new RuntimeManager({
       artifactStore: app.locals.artifactStore,
       browserExtensionRegistry: app.locals.browserExtensionRegistry,
+      desktopCompanionRegistry: app.locals.desktopCompanionRegistry,
+      shellWorkerPool,
     }),
   );
-  logServiceReady('Runtime manager ready');
+  logServiceReady('Runtime manager + shell worker pool ready');
   return runtimeManager;
 }
 
@@ -501,6 +513,10 @@ async function startServices(app, io) {
       mcpClient,
       skillRunner,
     }));
+    const toolPolicyService = registerLocal(app, 'toolPolicyService', new ToolPolicyService());
+    const approvalGateService = registerLocal(app, 'approvalGateService', new ApprovalGateService({ io }));
+    registerToolSecurityHooks(toolPolicyService, approvalGateService);
+    logServiceReady('Tool security hooks registered');
     agentEngine.learningManager = app.locals.learningManager;
 
     createMultiStep(app, agentEngine, io);
@@ -555,6 +571,9 @@ async function startServices(app, io) {
 async function stopServices(app) {
   const tasks = [];
   console.log('[Services] Stopping services');
+  if (app.locals.memoryManager) {
+    app.locals.memoryManager.stopEmbeddingIndexBackfill();
+  }
   if (app.locals.memoryReconciliationTimer) {
     clearInterval(app.locals.memoryReconciliationTimer);
     app.locals.memoryReconciliationTimer = null;

package/server/services/memory/consolidation.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const MEMORY_RELATIONS = new Set(['new', 'updates', 'extends', 'derives']);
+const MEMORY_CATEGORIES = new Set([
+  'identity',
+  'preferences',
+  'projects',
+  'contacts',
+  'events',
+  'tasks',
+  'episodic',
+  'assistant_self',
+]);
+
+function cleanText(value, maxLength) {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, maxLength);
+}
+
+function normalizeDate(value) {
+  const text = cleanText(value, 80);
+  if (!text) return null;
+  const timestamp = Date.parse(text);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+function normalizeConfidence(value) {
+  const confidence = Number(value);
+  if (!Number.isFinite(confidence)) return 0.7;
+  return Math.max(0, Math.min(1, confidence));
+}
+
+function normalizeMemoryCandidate(candidate) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return null;
+  }
+
+  const subject = cleanText(candidate.subject, 180);
+  const predicate = cleanText(candidate.predicate, 120).toLowerCase();
+  const object = cleanText(candidate.object, 900);
+  const memory = cleanText(candidate.memory, 1200);
+  if (!subject || !predicate || !object || !memory) return null;
+
+  const relation = cleanText(candidate.relation, 24).toLowerCase();
+  const category = cleanText(candidate.category, 40).toLowerCase();
+
+  const finalRelation = MEMORY_RELATIONS.has(relation) ? relation : 'new';
+  let finalConfidence = normalizeConfidence(candidate.confidence);
+  if (finalRelation === 'derives') {
+    finalConfidence = Math.min(finalConfidence, 0.6);
+  }
+
+  return {
+    memory,
+    subject,
+    predicate,
+    object,
+    relation: finalRelation,
+    category: MEMORY_CATEGORIES.has(category) ? category : 'episodic',
+    confidence: finalConfidence,
+    importance: Math.max(1, Math.min(10, Number(candidate.importance) || 5)),
+    isStatic: candidate.is_static === true || candidate.isStatic === true,
+    validFrom: normalizeDate(candidate.valid_from || candidate.validFrom),
+    validTo: normalizeDate(candidate.valid_to || candidate.validTo),
+    forgetAfter: normalizeDate(candidate.forget_after || candidate.forgetAfter),
+    evidence: cleanText(candidate.evidence, 500),
+  };
+}
+
+function normalizeMemoryCandidates(value, limit = 12) {
+  if (!Array.isArray(value)) return [];
+  const candidates = [];
+  const seen = new Set();
+
+  for (const item of value) {
+    const candidate = normalizeMemoryCandidate(item);
+    if (!candidate) continue;
+    const key = [
+      candidate.subject.toLowerCase(),
+      candidate.predicate,
+      candidate.object.toLowerCase(),
+    ].join('\u0000');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    candidates.push(candidate);
+    if (candidates.length >= limit) break;
+  }
+
+  return candidates;
+}
+
+function buildMemoryConsolidationInstructions(currentDateTime) {
+  return [
+    'Also extract durable memory candidates from the thread.',
+    `Current date/time: ${currentDateTime}. Resolve relative dates against this value.`,
+    'A memory candidate must be an atomic fact that will improve a future conversation.',
+    'Prefer explicit user statements and verified outcomes. Do not turn assistant guesses, suggestions, questions, or unverified claims into user facts.',
+    'Exclude secrets, credentials, private tokens, raw tool output, routine task narration, and facts useful only inside this thread.',
+    'Use relation="updates" when a fact replaces an older value for the same subject and predicate.',
+    'Use relation="extends" when it adds compatible detail without replacing the prior fact.',
+    'Use relation="derives" only for a strongly supported inference and lower its confidence.',
+    'Use is_static=true only for stable identity or durable preference facts.',
+    'Set valid_from, valid_to, or forget_after as ISO-8601 timestamps when the thread provides temporal boundaries.',
+    'Return an empty memory_candidates array when nothing is worth retaining.',
+  ].join(' ');
+}
+
+module.exports = {
+  buildMemoryConsolidationInstructions,
+  normalizeMemoryCandidate,
+  normalizeMemoryCandidates,
+};

package/server/services/memory/embedding_index.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const { deserializeEmbedding } = require('./embeddings');
+
+const BAND_COUNT = 10;
+const BITS_PER_BAND = 14;
+const INDEX_VERSION = 3;
+const DEFAULT_CANDIDATE_LIMIT = 600;
+
+function sampledCoordinate(dimension, bandIndex, bitIndex) {
+  let value = Math.imul(bandIndex + 1, 0x9e3779b1) ^ Math.imul(bitIndex + 1, 0x85ebca6b);
+  value ^= value >>> 16;
+  value = Math.imul(value, 0x7feb352d);
+  value ^= value >>> 15;
+  return (value >>> 0) % dimension;
+}
+
+function createEmbeddingBands(vector) {
+  if (!vector || !Number.isInteger(vector.length) || vector.length < BITS_PER_BAND) {
+    return [];
+  }
+
+  const bands = [];
+  for (let bandIndex = 0; bandIndex < BAND_COUNT; bandIndex += 1) {
+    let bandValue = 0;
+    for (let bitIndex = 0; bitIndex < BITS_PER_BAND; bitIndex += 1) {
+      const coordinate = sampledCoordinate(vector.length, bandIndex, bitIndex);
+      if (Number(vector[coordinate]) >= 0) {
+        bandValue |= 1 << bitIndex;
+      }
+    }
+    bands.push({
+      bandIndex,
+      bandValue,
+      dimension: vector.length,
+    });
+  }
+  return bands;
+}
+
+function replaceMemoryEmbeddingIndex(db, {
+  memoryId,
+  userId,
+  agentId,
+  embedding,
+}) {
+  const vector = typeof embedding === 'string'
+    ? deserializeEmbedding(embedding)
+    : embedding;
+  const bands = createEmbeddingBands(vector);
+
+  const replace = db.transaction(() => {
+    db.prepare('DELETE FROM memory_embedding_bands WHERE memory_id = ?').run(memoryId);
+    if (!bands.length) return;
+    const insert = db.prepare(
+      `INSERT INTO memory_embedding_bands (
+         memory_id, user_id, agent_id, dimension, index_version, band_index, band_value, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))`
+    );
+    for (const band of bands) {
+      insert.run(
+        memoryId,
+        userId,
+        agentId || '',
+        band.dimension,
+        INDEX_VERSION,
+        band.bandIndex,
+        band.bandValue,
+      );
+    }
+  });
+  replace();
+  return bands.length;
+}
+
+function buildBandProbes(vector) {
+  const probesByBand = [];
+  for (const band of createEmbeddingBands(vector)) {
+    const values = [band.bandValue];
+    for (let bitIndex = 0; bitIndex < BITS_PER_BAND; bitIndex += 1) {
+      values.push(band.bandValue ^ (1 << bitIndex));
+      for (let secondBit = bitIndex + 1; secondBit < BITS_PER_BAND; secondBit += 1) {
+        values.push(band.bandValue ^ (1 << bitIndex) ^ (1 << secondBit));
+      }
+    }
+    probesByBand.push({
+      bandIndex: band.bandIndex,
+      values,
+    });
+  }
+  return probesByBand;
+}
+
+function findEmbeddingCandidates(db, {
+  userId,
+  agentId,
+  embedding,
+  limit = DEFAULT_CANDIDATE_LIMIT,
+}) {
+  const vector = typeof embedding === 'string'
+    ? deserializeEmbedding(embedding)
+    : embedding;
+  const probesByBand = buildBandProbes(vector);
+  if (!probesByBand.length) return [];
+
+  const matches = new Map();
+  for (const band of probesByBand) {
+    const placeholders = band.values.map(() => '?').join(', ');
+    const rows = db.prepare(
+      `SELECT memory_id
+       FROM memory_embedding_bands
+       WHERE user_id = ?
+         AND agent_id = ?
+         AND dimension = ?
+         AND index_version = ?
+         AND band_index = ?
+         AND band_value IN (${placeholders})`
+    ).all(
+      userId,
+      agentId || '',
+      vector.length,
+      INDEX_VERSION,
+      band.bandIndex,
+      ...band.values,
+    );
+    for (const row of rows) {
+      matches.set(row.memory_id, (matches.get(row.memory_id) || 0) + 1);
+    }
+  }
+
+  return [...matches.entries()]
+    .sort((left, right) => right[1] - left[1])
+    .slice(0, Math.max(1, Math.min(Number(limit) || DEFAULT_CANDIDATE_LIMIT, 2000)))
+    .map(([memoryId, bandMatches]) => ({
+      memory_id: memoryId,
+      band_matches: bandMatches,
+    }));
+}
+
+function backfillEmbeddingIndex(db, { limit = 500 } = {}) {
+  const rows = db.prepare(
+    `SELECT m.id, m.user_id, m.agent_id, m.embedding
+     FROM memories m
+     LEFT JOIN memory_embedding_bands idx
+       ON idx.memory_id = m.id AND idx.index_version = ?
+     WHERE m.archived = 0
+       AND m.embedding IS NOT NULL
+       AND idx.memory_id IS NULL
+     ORDER BY m.updated_at DESC
+     LIMIT ?`
+  ).all(
+    INDEX_VERSION,
+    Math.max(1, Math.min(Number(limit) || 500, 5000)),
+  );
+
+  for (const row of rows) {
+    replaceMemoryEmbeddingIndex(db, {
+      memoryId: row.id,
+      userId: row.user_id,
+      agentId: row.agent_id,
+      embedding: row.embedding,
+    });
+  }
+  return rows.length;
+}
+
+module.exports = {
+  BAND_COUNT,
+  BITS_PER_BAND,
+  INDEX_VERSION,
+  backfillEmbeddingIndex,
+  createEmbeddingBands,
+  findEmbeddingCandidates,
+  replaceMemoryEmbeddingIndex,
+};

package/server/services/memory/embeddings.js

@@ -141,12 +141,31 @@ async function getOpenAIEmbedding(text) {
  * @returns {Float32Array|null}
  */
 async function getEmbedding(text, provider) {
+  const result = await getEmbeddingWithMetadata(text, provider);
+  return result?.vector || null;
+}
+
+async function getEmbeddingWithMetadata(text, provider) {
   if (!text || !text.trim()) return null;
   if (provider === 'google' && process.env.GOOGLE_AI_KEY) {
     const vec = await getGeminiEmbedding(text);
-    if (vec) return vec;
+    if (vec) {
+      return {
+        vector: vec,
+        provider: 'google',
+        model: GOOGLE_MODEL,
+        dimensions: vec.length,
+      };
+    }
   }
-  return getOpenAIEmbedding(text);
+  const vec = await getOpenAIEmbedding(text);
+  if (!vec) return null;
+  return {
+    vector: vec,
+    provider: 'openai',
+    model: OPENAI_MODEL,
+    dimensions: vec.length,
+  };
 }
 
 /**
@@ -203,6 +222,7 @@ function keywordSimilarity(query, text) {
 
 module.exports = {
   getEmbedding,
+  getEmbeddingWithMetadata,
   cosineSimilarity,
   serializeEmbedding,
   deserializeEmbedding,