@agentic-robotics/mcp 0.1.3 → 0.2.0

package/src/memory.ts

@@ -1,14 +1,11 @@
 /**
  * AgentDB Reflexion Memory Integration
  *
- * Enables robot learning from past experiences with 100µs retrieval
+ * Enables robot learning from past experiences with secure command execution
+ * SECURITY: Uses spawn() with argument arrays to prevent command injection
  */
 
 import { spawn } from 'child_process';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-
-const execAsync = promisify(exec);
 
 export interface Episode {
   sessionId: string;
@@ -29,11 +26,51 @@ export interface Memory {
   timestamp: number;
 }
 
+/**
+ * Helper to safely spawn a command and capture output
+ * Prevents command injection by using spawn with argument array
+ */
+function spawnAsync(
+  command: string,
+  args: string[],
+  env?: Record<string, string>
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: { ...process.env, ...env },
+      shell: false, // Critical: disable shell interpretation
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({ stdout, stderr, code: code || 0 });
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
 export class AgentDBMemory {
   private dbPath: string;
   private initialized: boolean = false;
 
   constructor(dbPath: string) {
+    // Validate dbPath to prevent path traversal
+    if (!dbPath || dbPath.includes('..') || dbPath.includes(';') || dbPath.includes('|')) {
+      throw new Error('Invalid database path');
+    }
     this.dbPath = dbPath;
   }
 
@@ -41,38 +78,64 @@ export class AgentDBMemory {
     if (this.initialized) return;
 
     try {
-      // Initialize AgentDB database
-      const { stdout, stderr } = await execAsync(
-        `npx agentdb init "${this.dbPath}" --dimension 768 --preset medium`
-      );
+      // Initialize AgentDB database - use spawn with argument array for security
+      const { stdout, stderr, code } = await spawnAsync('npx', [
+        'agentdb',
+        'init',
+        this.dbPath,
+        '--dimension',
+        '768',
+        '--preset',
+        'medium',
+      ]);
 
-      console.error('AgentDB initialized:', this.dbPath);
-      this.initialized = true;
+      if (code === 0 || stderr.includes('already exists')) {
+        console.error('AgentDB initialized:', this.dbPath);
+        this.initialized = true;
+      } else {
+        throw new Error(`Initialization failed: ${stderr}`);
+      }
     } catch (error: any) {
       // Database might already exist
-      if (!error.message.includes('already exists')) {
-        console.error('AgentDB initialization warning:', error.message);
+      if (error.message?.includes('already exists')) {
+        this.initialized = true;
+      } else {
+        throw new Error(`Failed to initialize AgentDB: ${error.message}`);
       }
-      this.initialized = true;
     }
   }
 
   async storeEpisode(episode: Episode): Promise<void> {
-    const cmd = [
-      'npx agentdb reflexion store',
-      `"${episode.sessionId}"`,
-      `"${episode.taskName}"`,
-      episode.confidence.toString(),
-      episode.success.toString(),
-      episode.outcome ? `"${episode.outcome}"` : '""',
-    ].join(' ');
+    if (!this.initialized) {
+      throw new Error('AgentDB not initialized. Call initialize() first.');
+    }
 
     try {
-      await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`);
+      // Use spawn with argument array to prevent command injection
+      const { code, stderr } = await spawnAsync(
+        'npx',
+        [
+          'agentdb',
+          'reflexion',
+          'store',
+          episode.sessionId,
+          episode.taskName,
+          episode.confidence.toString(),
+          episode.success.toString(),
+          episode.outcome || '',
+        ],
+        { AGENTDB_PATH: this.dbPath }
+      );
+
+      if (code !== 0) {
+        throw new Error(`Command failed: ${stderr}`);
+      }
+
       console.error(`Stored episode: ${episode.taskName} (success: ${episode.success})`);
     } catch (error: any) {
-      console.error('Error storing episode:', error.message);
-      throw error;
+      const errorMsg = `Failed to store episode "${episode.taskName}": ${error.message}`;
+      console.error('Error storing episode:', errorMsg);
+      throw new Error(errorMsg); // Throw instead of silently failing
     }
   }
 
@@ -86,27 +149,38 @@ export class AgentDBMemory {
       synthesizeContext?: boolean;
     } = {}
   ): Promise<Memory[]> {
-    let cmd = `npx agentdb reflexion retrieve "${query}" --k ${k}`;
+    if (!this.initialized) {
+      throw new Error('AgentDB not initialized. Call initialize() first.');
+    }
+
+    // Build safe argument array
+    const args = ['agentdb', 'reflexion', 'retrieve', query, '--k', k.toString()];
 
     if (options.minReward !== undefined) {
-      cmd += ` --min-reward ${options.minReward}`;
+      args.push('--min-reward', options.minReward.toString());
     }
     if (options.onlySuccesses) {
-      cmd += ' --only-successes';
+      args.push('--only-successes');
     }
     if (options.onlyFailures) {
-      cmd += ' --only-failures';
+      args.push('--only-failures');
     }
     if (options.synthesizeContext) {
-      cmd += ' --synthesize-context';
+      args.push('--synthesize-context');
     }
 
     try {
-      const { stdout } = await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`);
+      const { stdout, code, stderr } = await spawnAsync('npx', args, {
+        AGENTDB_PATH: this.dbPath,
+      });
+
+      if (code !== 0) {
+        throw new Error(`Command failed: ${stderr}`);
+      }
 
       // Parse JSON output
       const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('[') || line.startsWith('{'));
+      const jsonLine = lines.find((line) => line.startsWith('[') || line.startsWith('{'));
 
       if (jsonLine) {
         const data = JSON.parse(jsonLine);
@@ -115,8 +189,8 @@ export class AgentDBMemory {
 
       return [];
     } catch (error: any) {
-      console.error('Error retrieving memories:', error.message);
-      return [];
+      // Throw error instead of silently returning empty array
+      throw new Error(`Failed to retrieve memories for query "${query}": ${error.message}`);
     }
   }
 
@@ -128,21 +202,41 @@ export class AgentDBMemory {
       domain?: string;
     } = {}
   ): Promise<{ memories: Memory[]; context?: string }> {
+    if (!this.initialized) {
+      throw new Error('AgentDB not initialized. Call initialize() first.');
+    }
+
     const { k = 5, minConfidence = 0.0, domain } = options;
 
-    let cmd = `npx agentdb query --query "${query}" --k ${k} --min-confidence ${minConfidence}`;
+    // Build safe argument array
+    const args = [
+      'agentdb',
+      'query',
+      '--query',
+      query,
+      '--k',
+      k.toString(),
+      '--min-confidence',
+      minConfidence.toString(),
+    ];
 
     if (domain) {
-      cmd += ` --domain "${domain}"`;
+      args.push('--domain', domain);
     }
 
-    cmd += ' --synthesize-context --format json';
+    args.push('--synthesize-context', '--format', 'json');
 
     try {
-      const { stdout } = await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`);
+      const { stdout, code, stderr } = await spawnAsync('npx', args, {
+        AGENTDB_PATH: this.dbPath,
+      });
+
+      if (code !== 0) {
+        throw new Error(`Command failed: ${stderr}`);
+      }
 
       const lines = stdout.trim().split('\n');
-      const jsonLine = lines.find(line => line.startsWith('[') || line.startsWith('{'));
+      const jsonLine = lines.find((line) => line.startsWith('[') || line.startsWith('{'));
 
       if (jsonLine) {
         const data = JSON.parse(jsonLine);
@@ -154,8 +248,8 @@ export class AgentDBMemory {
 
       return { memories: [] };
     } catch (error: any) {
-      console.error('Error querying with context:', error.message);
-      return { memories: [] };
+      // Throw error instead of silently returning empty array
+      throw new Error(`Failed to query with context "${query}": ${error.message}`);
     }
   }
 
@@ -164,29 +258,54 @@ export class AgentDBMemory {
     minReward?: number;
     timeWindowDays?: number;
   } = {}): Promise<void> {
-    const {
-      minAttempts = 3,
-      minReward = 0.7,
-      timeWindowDays = 7,
-    } = options;
+    if (!this.initialized) {
+      throw new Error('AgentDB not initialized. Call initialize() first.');
+    }
 
-    const cmd = `npx agentdb skill consolidate ${minAttempts} ${minReward} ${timeWindowDays} true`;
+    const { minAttempts = 3, minReward = 0.7, timeWindowDays = 7 } = options;
 
     try {
-      await execAsync(`AGENTDB_PATH="${this.dbPath}" ${cmd}`);
+      const { code, stderr } = await spawnAsync(
+        'npx',
+        [
+          'agentdb',
+          'skill',
+          'consolidate',
+          minAttempts.toString(),
+          minReward.toString(),
+          timeWindowDays.toString(),
+          'true',
+        ],
+        { AGENTDB_PATH: this.dbPath }
+      );
+
+      if (code !== 0) {
+        throw new Error(`Command failed: ${stderr}`);
+      }
+
       console.error('Skills consolidated from successful episodes');
     } catch (error: any) {
-      console.error('Error consolidating skills:', error.message);
+      throw new Error(`Failed to consolidate skills: ${error.message}`);
     }
   }
 
   async getStats(): Promise<any> {
+    if (!this.initialized) {
+      throw new Error('AgentDB not initialized. Call initialize() first.');
+    }
+
     try {
-      const { stdout } = await execAsync(`AGENTDB_PATH="${this.dbPath}" npx agentdb db stats`);
+      const { stdout, code, stderr } = await spawnAsync('npx', ['agentdb', 'db', 'stats'], {
+        AGENTDB_PATH: this.dbPath,
+      });
+
+      if (code !== 0) {
+        throw new Error(`Command failed: ${stderr}`);
+      }
+
       return { stats: stdout.trim() };
     } catch (error: any) {
-      console.error('Error getting stats:', error.message);
-      return { stats: 'unavailable' };
+      throw new Error(`Failed to get stats: ${error.message}`);
     }
   }
 

package/src/optimized-benchmark.ts

@@ -1,302 +0,0 @@
-/**
- * Optimized Benchmark Suite
- *
- * Uses JavaScript APIs directly for accurate performance measurement
- */
-
-import { OptimizedAgentDBMemory } from './optimized-memory.js';
-import type { Episode } from './memory.js';
-
-interface BenchmarkResult {
-  name: string;
-  iterations: number;
-  totalTime: number;
-  avgTime: number;
-  minTime: number;
-  maxTime: number;
-  opsPerSec: number;
-  p50: number;
-  p95: number;
-  p99: number;
-}
-
-interface BenchmarkSuite {
-  agentdb: {
-    storeEpisode: BenchmarkResult;
-    retrieveMemories: BenchmarkResult;
-    queryWithContext: BenchmarkResult;
-    consolidateSkills: BenchmarkResult;
-    searchSkills: BenchmarkResult;
-  };
-  overall: {
-    totalTime: number;
-    timestamp: string;
-  };
-}
-
-export class OptimizedBenchmark {
-  private memory: OptimizedAgentDBMemory;
-
-  constructor() {
-    this.memory = new OptimizedAgentDBMemory('./optimized-benchmark.db');
-  }
-
-  async initialize(): Promise<void> {
-    console.log('🏁 Initializing optimized benchmark suite...\n');
-    await this.memory.initialize();
-    console.log('✅ Benchmark suite ready\n');
-  }
-
-  /**
-   * Run complete benchmark suite
-   */
-  async runAll(): Promise<BenchmarkSuite> {
-    const suiteStartTime = Date.now();
-
-    console.log('┌─────────────────────────────────────────────────────────┐');
-    console.log('│   Optimized Integration Benchmark Suite                 │');
-    console.log('│   AgentDB JavaScript API Performance Test               │');
-    console.log('└─────────────────────────────────────────────────────────┘\n');
-
-    // AgentDB Benchmarks with JS API
-    console.log('📊 AGENTDB BENCHMARKS (JS API)\n');
-
-    const storeEpisode = await this.benchmarkStoreEpisode(1000);
-    this.printResult('Store Episode', storeEpisode);
-
-    const retrieveMemories = await this.benchmarkRetrieveMemories(500);
-    this.printResult('Retrieve Memories', retrieveMemories);
-
-    const queryWithContext = await this.benchmarkQueryWithContext(300);
-    this.printResult('Query with Context', queryWithContext);
-
-    const consolidateSkills = await this.benchmarkConsolidateSkills(10);
-    this.printResult('Consolidate Skills', consolidateSkills);
-
-    const searchSkills = await this.benchmarkSearchSkills(200);
-    this.printResult('Search Skills', searchSkills);
-
-    const totalTime = Date.now() - suiteStartTime;
-
-    console.log('\n┌─────────────────────────────────────────────────────────┐');
-    console.log('│   BENCHMARK COMPLETE                                    │');
-    console.log(`│   Total Time: ${(totalTime / 1000).toFixed(2)}s                                 │`);
-    console.log('└─────────────────────────────────────────────────────────┘\n');
-
-    // Print performance metrics
-    const metrics = this.memory.getMetrics();
-    console.log('📈 PERFORMANCE METRICS\n');
-    console.log(`  Store Operations:    ${metrics.storeCount}`);
-    console.log(`  Avg Store Time:      ${metrics.avgStoreTime.toFixed(3)}ms`);
-    console.log(`  Retrieve Operations: ${metrics.retrieveCount}`);
-    console.log(`  Avg Retrieve Time:   ${metrics.avgRetrieveTime.toFixed(3)}ms\n`);
-
-    return {
-      agentdb: {
-        storeEpisode,
-        retrieveMemories,
-        queryWithContext,
-        consolidateSkills,
-        searchSkills,
-      },
-      overall: {
-        totalTime,
-        timestamp: new Date().toISOString(),
-      },
-    };
-  }
-
-  /**
-   * Benchmark: Store Episode (JS API)
-   */
-  private async benchmarkStoreEpisode(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const episode: Episode = {
-        sessionId: `bench-${i}`,
-        taskName: 'navigation',
-        confidence: Math.random(),
-        success: Math.random() > 0.3,
-        outcome: 'Completed navigation task',
-        strategy: 'adaptive_planning',
-        metadata: { x: i, y: i * 2, latency: Math.random() * 100 },
-      };
-
-      const start = performance.now();
-      await this.memory.storeEpisode(episode);
-      times.push(performance.now() - start);
-
-      if (i % 100 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Store Episode', times);
-  }
-
-  /**
-   * Benchmark: Retrieve Memories (JS API)
-   */
-  private async benchmarkRetrieveMemories(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    const queries = [
-      'navigation task',
-      'object detection',
-      'path planning',
-      'sensor fusion',
-      'motor control',
-    ];
-
-    for (let i = 0; i < iterations; i++) {
-      const query = queries[i % queries.length];
-
-      const start = performance.now();
-      await this.memory.retrieveMemories(query, 5, {
-        onlySuccesses: true,
-        synthesizeContext: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 50 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Retrieve Memories', times);
-  }
-
-  /**
-   * Benchmark: Query with Context (JS API)
-   */
-  private async benchmarkQueryWithContext(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.queryWithContext('warehouse navigation', {
-        k: 10,
-        minConfidence: 0.5,
-        synthesizeReasoning: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 30 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Query with Context', times);
-  }
-
-  /**
-   * Benchmark: Consolidate Skills (JS API)
-   */
-  private async benchmarkConsolidateSkills(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.consolidateSkills({
-        minAttempts: 3,
-        minReward: 0.7,
-        timeWindowDays: 7,
-        enablePruning: true,
-      });
-      times.push(performance.now() - start);
-
-      if (i % 2 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Consolidate Skills', times);
-  }
-
-  /**
-   * Benchmark: Search Skills (JS API)
-   */
-  private async benchmarkSearchSkills(iterations: number): Promise<BenchmarkResult> {
-    const times: number[] = [];
-
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.memory.searchSkills('navigation', {
-        k: 5,
-        minSuccessRate: 0.5,
-        sortBy: 'success_rate',
-      });
-      times.push(performance.now() - start);
-
-      if (i % 20 === 0 && i > 0) {
-        process.stderr.write(`  Progress: ${i}/${iterations}\r`);
-      }
-    }
-
-    return this.calculateStats('Search Skills', times);
-  }
-
-  /**
-   * Calculate statistics from timing data
-   */
-  private calculateStats(name: string, times: number[]): BenchmarkResult {
-    const sorted = [...times].sort((a, b) => a - b);
-    const total = times.reduce((a, b) => a + b, 0);
-
-    return {
-      name,
-      iterations: times.length,
-      totalTime: total,
-      avgTime: total / times.length,
-      minTime: sorted[0],
-      maxTime: sorted[sorted.length - 1],
-      opsPerSec: (times.length / total) * 1000,
-      p50: sorted[Math.floor(sorted.length * 0.50)],
-      p95: sorted[Math.floor(sorted.length * 0.95)],
-      p99: sorted[Math.floor(sorted.length * 0.99)],
-    };
-  }
-
-  /**
-   * Print benchmark result
-   */
-  private printResult(name: string, result: BenchmarkResult): void {
-    console.log(`${name}:`);
-    console.log(`  Iterations:  ${result.iterations.toLocaleString()}`);
-    console.log(`  Avg Time:    ${result.avgTime.toFixed(3)}ms`);
-    console.log(`  Min/Max:     ${result.minTime.toFixed(3)}ms / ${result.maxTime.toFixed(3)}ms`);
-    console.log(`  p50/p95/p99: ${result.p50.toFixed(3)}ms / ${result.p95.toFixed(3)}ms / ${result.p99.toFixed(3)}ms`);
-    console.log(`  Ops/sec:     ${result.opsPerSec.toFixed(0)}`);
-    console.log('');
-  }
-
-  /**
-   * Export results to JSON
-   */
-  async exportResults(suite: BenchmarkSuite, filename: string): Promise<void> {
-    const fs = await import('fs/promises');
-    await fs.writeFile(filename, JSON.stringify(suite, null, 2));
-    console.log(`📁 Results exported to ${filename}`);
-  }
-
-  async close(): Promise<void> {
-    await this.memory.close();
-  }
-}
-
-// CLI entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const benchmark = new OptimizedBenchmark();
-
-  try {
-    await benchmark.initialize();
-    const results = await benchmark.runAll();
-    await benchmark.exportResults(results, './optimized-benchmark-results.json');
-  } catch (error) {
-    console.error('❌ Benchmark failed:', error);
-    process.exit(1);
-  } finally {
-    await benchmark.close();
-  }
-}