total-recall-brain 3.3.0 → 3.5.0

package/src/core/runtime.mjs

@@ -43,7 +43,6 @@ export function findBinaryInPath(binaryName) {
 
 const DEFAULT_AGENTS = [
   { name: 'antigravity', binary: 'antigravity', flags: '--sandbox=false --yolo -o json', priority: 1, enabled: true, exec: 'flag' },
-  { name: 'gemini',      binary: 'gemini',      flags: '--sandbox=false --yolo -o json', priority: 2, enabled: true, exec: 'flag' },
   { name: 'claude',      binary: 'claude',      flags: '--output-format json --permission-mode bypassPermissions', priority: 3, enabled: true, exec: 'flag' },
   { name: 'codex',       binary: 'codex',       flags: '--full-auto --json', priority: 4, enabled: true, exec: 'subcommand' },
 ];
@@ -255,6 +254,27 @@ export async function callLocalRuntime(prompt, system, config) {
 
   let lastError;
 
+  // Load dynamic secrets from secrets.enc to ensure changes take effect immediately without server restart
+  let dynamicSecrets = {};
+  try {
+    const pathsToCheck = [
+      path.join(process.cwd(), '.agent', 'secrets.enc'),
+      path.join(agentDir, 'secrets.enc'),
+      path.join(os.homedir(), '.agent', 'skills', 'total-recall', 'config', 'secrets.enc'),
+      path.join(agentDir, 'skills', 'total-recall', 'config', 'secrets.enc'),
+    ];
+    for (const p of pathsToCheck) {
+      if (fs.existsSync(p)) {
+        try {
+          dynamicSecrets = JSON.parse(fs.readFileSync(p, 'utf8') || '{}');
+          if (Object.keys(dynamicSecrets).length > 0) {
+            break;
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+
   // Try agents in priority order with retry budget
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const agent = attempt === 0 ? resolveAgent(config) : resolveAgent({
@@ -290,12 +310,15 @@ export async function callLocalRuntime(prompt, system, config) {
       maxBuffer: 10 * 1024 * 1024,
       env: {
         ...process.env,
-        GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || googleApiKey,
-        TAVILY_API_KEY: process.env.TAVILY_API_KEY || tavilyApiKey,
-        BRAVE_API_KEY: process.env.BRAVE_API_KEY || braveApiKey,
-        EXA_API_KEY: process.env.EXA_API_KEY || exaApiKey,
-        SERPER_API_KEY: process.env.SERPER_API_KEY || serperApiKey,
-        GITHUB_TOKEN: process.env.GITHUB_TOKEN || githubToken,
+        GOOGLE_API_KEY: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || dynamicSecrets.google_api_key || googleApiKey,
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || dynamicSecrets.google_api_key || googleApiKey,
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || dynamicSecrets.anthropic_api_key,
+        OPENAI_API_KEY: process.env.OPENAI_API_KEY || dynamicSecrets.openai_api_key,
+        TAVILY_API_KEY: process.env.TAVILY_API_KEY || dynamicSecrets.tavily_api_key || tavilyApiKey,
+        BRAVE_API_KEY: process.env.BRAVE_API_KEY || dynamicSecrets.brave_api_key || braveApiKey,
+        EXA_API_KEY: process.env.EXA_API_KEY || dynamicSecrets.exa_api_key || exaApiKey,
+        SERPER_API_KEY: process.env.SERPER_API_KEY || dynamicSecrets.serper_api_key || serperApiKey,
+        GITHUB_TOKEN: process.env.GITHUB_TOKEN || dynamicSecrets.github_token || githubToken,
       },
       cwd: process.cwd(),
     });

package/src/core/sandbox.mjs

@@ -1,10 +1,52 @@
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import crypto from "node:crypto";
 import { logger } from './logger.mjs';
 
+let macSandboxProbe = null;
+
+function escapeSandboxPath(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function buildMacSandboxProfile({ allowNetwork }) {
+  return [
+    '(version 1)',
+    '(allow default)',
+    '(deny file-write*)',
+    '(allow file-write*',
+    `  (subpath "/private/tmp")`,
+    `  (subpath "/tmp")`,
+    `  (subpath "${escapeSandboxPath(process.cwd())}")`,
+    `  (subpath "${escapeSandboxPath(os.tmpdir())}")`,
+    `)`,
+    allowNetwork ? '' : '(deny network-outbound)'
+  ].filter(Boolean).join('\n');
+}
+
+function canUseMacSandbox(profile) {
+  if (process.platform !== 'darwin') return false;
+  if (macSandboxProbe !== null) return macSandboxProbe;
+  const result = spawnSync('sandbox-exec', [
+    '-p',
+    profile,
+    process.execPath,
+    '--no-warnings',
+    '-e',
+    'process.exit(0)'
+  ], {
+    encoding: 'utf8',
+    timeout: 1500
+  });
+  macSandboxProbe = result.status === 0;
+  if (!macSandboxProbe) {
+    logger.warn('sandbox', 'macOS sandbox-exec probe failed; falling back to Node process limits.');
+  }
+  return macSandboxProbe;
+}
+
 /**
  * Command Sanitizer / Whitelist Execution Validator
  * Blocks high-risk actions (destructive deletes, reverse shells, shell pipes)
@@ -62,33 +104,21 @@ export async function runInSandbox(scriptPath, timeoutMs = 5000, options = {}) {
   safeEnv.NODE_OPTIONS = '--experimental-vm-modules';
 
   // OS-specific sandboxing wrappers
-  let cmd = 'node';
+  let cmd = process.execPath;
   let args = ['--no-warnings', scriptPath];
   let tempSbProfilePath = null;
 
   try {
     if (process.platform === 'darwin') {
       // macOS sandbox-exec integration
-      const profile = [
-        '(version 1)',
-        '(allow default)',
-        '(deny file-write*)',
-        '(allow file-write*',
-        `  (subpath "/private/tmp")`,
-        `  (subpath "/tmp")`,
-        `  (subpath "${process.cwd()}")`,
-        `  (subpath "${os.tmpdir()}")`,
-        `)`,
-        allowNetwork 
-          ? '' 
-          : '(deny network-outbound)'
-      ].filter(Boolean).join('\n');
-
-      tempSbProfilePath = path.join(os.tmpdir(), `tr-sandbox-${Date.now()}-${crypto.randomBytes(4).toString("hex")}.sb`);
-      fs.writeFileSync(tempSbProfilePath, profile, 'utf8');
-
-      cmd = 'sandbox-exec';
-      args = ['-f', tempSbProfilePath, 'node', '--no-warnings', scriptPath];
+      const profile = buildMacSandboxProfile({ allowNetwork });
+      if (canUseMacSandbox(profile)) {
+        tempSbProfilePath = path.join(os.tmpdir(), `tr-sandbox-${Date.now()}-${crypto.randomBytes(4).toString("hex")}.sb`);
+        fs.writeFileSync(tempSbProfilePath, profile, 'utf8');
+
+        cmd = 'sandbox-exec';
+        args = ['-f', tempSbProfilePath, process.execPath, '--no-warnings', scriptPath];
+      }
     } else if (process.platform === 'linux') {
       // Linux namespace isolation check via unshare
       const hasUnshare = fs.existsSync('/usr/bin/unshare') || fs.existsSync('/bin/unshare');
@@ -98,7 +128,7 @@ export async function runInSandbox(scriptPath, timeoutMs = 5000, options = {}) {
         if (!allowNetwork) {
           unshareArgs.push('--net');
         }
-        args = [...unshareArgs, 'node', '--no-warnings', scriptPath];
+        args = [...unshareArgs, process.execPath, '--no-warnings', scriptPath];
       }
     }
   } catch (err) {
@@ -117,14 +147,14 @@ export async function runInSandbox(scriptPath, timeoutMs = 5000, options = {}) {
     proc.stdout.on('data', (data) => { stdout += data.toString(); });
     proc.stderr.on('data', (data) => { stderr += data.toString(); });
 
-    proc.on('close', (code) => {
+    proc.on('close', (code, signal) => {
       if (tempSbProfilePath && fs.existsSync(tempSbProfilePath)) {
         try { fs.unlinkSync(tempSbProfilePath); } catch {}
       }
       if (code === 0) {
-        resolve({ success: true, output: stdout });
+        resolve({ success: true, output: stdout, code, signal });
       } else {
-        resolve({ success: false, output: stderr || stdout, code });
+        resolve({ success: false, output: stderr || stdout, code, signal });
       }
     });
 

package/src/core/scheduler.mjs

@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
 import crypto from 'crypto';
-import { loadNodes, atomicWrite, safeStringify } from './vault.mjs';
+import { atomicWrite, safeStringify } from './vault.mjs';
+import { getNodes } from './vault-cache.mjs';
 import { logger } from './logger.mjs';
 import { loadQueue, updateQueueItem } from './research-queue.mjs';
 
@@ -243,7 +244,7 @@ function generateProactiveResearchTask() {
  * Pick a random active memory node and create a clarity review task.
  */
 function generateClarityReviewTask(vaultDir) {
-  const nodes = loadNodes(vaultDir).filter((n) => n.status === 'active');
+  const nodes = getNodes(vaultDir).filter((n) => n.status === 'active');
   if (nodes.length === 0) {
     return makeFallbackTask('memory-maintenance', 'No active nodes to review');
   }
@@ -266,7 +267,7 @@ function generateClarityReviewTask(vaultDir) {
  * Pick the oldest fact node and create a staleness check task.
  */
 function generateStalenessCheckTask(vaultDir) {
-  const nodes = loadNodes(vaultDir)
+  const nodes = getNodes(vaultDir)
     .filter((n) => n.status === 'active' && n.category === 'facts')
     .sort((a, b) => {
       const aDate = new Date(a.last_accessed || a.updated || 0).getTime();
@@ -276,7 +277,7 @@ function generateStalenessCheckTask(vaultDir) {
 
   if (nodes.length === 0) {
     // No facts? Pick any old node
-    const allNodes = loadNodes(vaultDir).filter((n) => n.status === 'active');
+    const allNodes = getNodes(vaultDir).filter((n) => n.status === 'active');
     if (allNodes.length === 0) {
       return makeFallbackTask('research-acquisition', 'No facts to verify');
     }
@@ -314,7 +315,7 @@ function generateStalenessCheckTask(vaultDir) {
  * Pick a cluster of related nodes and create an inference task.
  */
 function generateInferenceTask(vaultDir) {
-  const nodes = loadNodes(vaultDir).filter((n) => n.status === 'active');
+  const nodes = getNodes(vaultDir).filter((n) => n.status === 'active');
   if (nodes.length < 3) {
     return makeFallbackTask('system2-deliberation', 'Not enough nodes for inference');
   }