@sparkleideas/browser 3.0.0-alpha.18

package/tests/memory-integration.test.ts

@@ -0,0 +1,277 @@
+/**
+ * @sparkleideas/browser - Memory Integration Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  ClaudeFlowMemoryAdapter,
+  BrowserMemoryManager,
+  createMemoryManager,
+  getMemoryAdapter,
+  type BrowserMemoryEntry,
+} from '../src/infrastructure/memory-integration.js';
+import type { BrowserTrajectory, Snapshot } from '../src/domain/types.js';
+
+describe('ClaudeFlowMemoryAdapter', () => {
+  let adapter: ClaudeFlowMemoryAdapter;
+
+  beforeEach(() => {
+    adapter = new ClaudeFlowMemoryAdapter('test-browser');
+  });
+
+  describe('store and retrieve', () => {
+    it('should store and retrieve a memory entry', async () => {
+      const entry: BrowserMemoryEntry = {
+        id: 'test-1',
+        type: 'trajectory',
+        key: 'test-1',
+        value: { goal: 'Login to app', steps: [] },
+        metadata: {
+          sessionId: 'session-1',
+          goal: 'Login to app',
+          success: true,
+          timestamp: new Date().toISOString(),
+        },
+      };
+
+      await adapter.store(entry);
+      const retrieved = await adapter.retrieve('test-browser:trajectory:test-1');
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe('test-1');
+      expect(retrieved?.metadata.goal).toBe('Login to app');
+    });
+
+    it('should return null for non-existent key', async () => {
+      const result = await adapter.retrieve('non-existent');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('search', () => {
+    beforeEach(async () => {
+      const entries: BrowserMemoryEntry[] = [
+        {
+          id: 'login-1',
+          type: 'trajectory',
+          key: 'login-1',
+          value: { goal: 'Login to dashboard' },
+          metadata: { sessionId: 's1', goal: 'Login to dashboard', timestamp: new Date().toISOString() },
+        },
+        {
+          id: 'login-2',
+          type: 'trajectory',
+          key: 'login-2',
+          value: { goal: 'Login to admin panel' },
+          metadata: { sessionId: 's1', goal: 'Login to admin panel', timestamp: new Date().toISOString() },
+        },
+        {
+          id: 'scrape-1',
+          type: 'pattern',
+          key: 'scrape-1',
+          value: { goal: 'Scrape product data' },
+          metadata: { sessionId: 's2', goal: 'Scrape product data', timestamp: new Date().toISOString() },
+        },
+      ];
+
+      for (const entry of entries) {
+        await adapter.store(entry);
+      }
+    });
+
+    it('should search by keyword', async () => {
+      const results = await adapter.search('login');
+      expect(results.length).toBe(2);
+      expect(results.every(r => r.entry.metadata.goal?.toLowerCase().includes('login'))).toBe(true);
+    });
+
+    it('should filter by type', async () => {
+      const results = await adapter.search('login', { type: 'trajectory' });
+      expect(results.every(r => r.entry.type === 'trajectory')).toBe(true);
+    });
+
+    it('should limit results with topK', async () => {
+      const results = await adapter.search('login', { topK: 1 });
+      expect(results.length).toBe(1);
+    });
+
+    it('should filter by minimum score', async () => {
+      const results = await adapter.search('login', { minScore: 0.5 });
+      expect(results.every(r => r.score >= 0.5)).toBe(true);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete an entry', async () => {
+      const entry: BrowserMemoryEntry = {
+        id: 'delete-test',
+        type: 'snapshot',
+        key: 'delete-test',
+        value: { url: 'https://example.com' },
+        metadata: { sessionId: 's1', timestamp: new Date().toISOString() },
+      };
+
+      await adapter.store(entry);
+      const deleted = await adapter.delete('test-browser:snapshot:delete-test');
+      expect(deleted).toBe(true);
+
+      const retrieved = await adapter.retrieve('test-browser:snapshot:delete-test');
+      expect(retrieved).toBeNull();
+    });
+  });
+
+  describe('list', () => {
+    it('should list entries with filters', async () => {
+      await adapter.store({
+        id: 'list-1',
+        type: 'trajectory',
+        key: 'list-1',
+        value: {},
+        metadata: { sessionId: 'list-session', success: true, timestamp: new Date().toISOString() },
+      });
+
+      await adapter.store({
+        id: 'list-2',
+        type: 'error',
+        key: 'list-2',
+        value: {},
+        metadata: { sessionId: 'list-session', success: false, timestamp: new Date().toISOString() },
+      });
+
+      const trajectories = await adapter.list({ type: 'trajectory' });
+      expect(trajectories.some(e => e.id === 'list-1')).toBe(true);
+
+      const failures = await adapter.list({ success: false });
+      expect(failures.some(e => e.id === 'list-2')).toBe(true);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return memory statistics', async () => {
+      await adapter.store({
+        id: 'stats-1',
+        type: 'trajectory',
+        key: 'stats-1',
+        value: {},
+        metadata: { sessionId: 's1', timestamp: new Date().toISOString() },
+      });
+
+      const stats = await adapter.getStats();
+      expect(stats.totalEntries).toBeGreaterThan(0);
+      expect(stats.byType).toBeDefined();
+      expect(stats.bySession).toBeDefined();
+    });
+  });
+});
+
+describe('BrowserMemoryManager', () => {
+  let manager: BrowserMemoryManager;
+
+  beforeEach(() => {
+    manager = createMemoryManager('test-session');
+  });
+
+  describe('storeTrajectory', () => {
+    it('should store a completed trajectory', async () => {
+      const trajectory: BrowserTrajectory = {
+        id: 'traj-1',
+        sessionId: 'test-session',
+        goal: 'Complete checkout flow',
+        steps: [
+          {
+            action: 'click',
+            input: { target: '#checkout' },
+            result: { success: true },
+            timestamp: new Date().toISOString(),
+          },
+        ],
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        success: true,
+      };
+
+      await manager.storeTrajectory(trajectory);
+      // No error means success
+    });
+  });
+
+  describe('storePattern', () => {
+    it('should store a learned pattern', async () => {
+      await manager.storePattern(
+        'pattern-1',
+        'Login to app',
+        [
+          { action: 'fill', selector: '#username', value: 'test' },
+          { action: 'fill', selector: '#password', value: 'pass' },
+          { action: 'click', selector: '#submit' },
+        ],
+        true
+      );
+      // No error means success
+    });
+  });
+
+  describe('storeSnapshot', () => {
+    it('should store a snapshot', async () => {
+      const snapshot: Snapshot = {
+        tree: { role: 'document', children: [] },
+        refs: {},
+        url: 'https://example.com',
+        title: 'Example',
+        timestamp: new Date().toISOString(),
+      };
+
+      await manager.storeSnapshot('snap-1', snapshot);
+      // No error means success
+    });
+  });
+
+  describe('storeError', () => {
+    it('should store an error', async () => {
+      const error = new Error('Element not found');
+      await manager.storeError('error-1', error, {
+        action: 'click',
+        selector: '#non-existent',
+        url: 'https://example.com',
+      });
+      // No error means success
+    });
+  });
+
+  describe('findSimilarTrajectories', () => {
+    it('should find trajectories similar to a goal', async () => {
+      const trajectory: BrowserTrajectory = {
+        id: 'traj-search-1',
+        sessionId: 'test-session',
+        goal: 'Login to dashboard',
+        steps: [],
+        startedAt: new Date().toISOString(),
+        success: true,
+      };
+
+      await manager.storeTrajectory(trajectory);
+      const similar = await manager.findSimilarTrajectories('Login');
+      // Should return results (may be empty depending on scoring)
+      expect(Array.isArray(similar)).toBe(true);
+    });
+  });
+
+  describe('getSessionStats', () => {
+    it('should return session statistics', async () => {
+      const stats = await manager.getSessionStats();
+      expect(stats.trajectories).toBeDefined();
+      expect(stats.patterns).toBeDefined();
+      expect(stats.snapshots).toBeDefined();
+      expect(stats.errors).toBeDefined();
+      expect(typeof stats.successRate).toBe('number');
+    });
+  });
+});
+
+describe('factory functions', () => {
+  it('getMemoryAdapter should return singleton', () => {
+    const adapter1 = getMemoryAdapter();
+    const adapter2 = getMemoryAdapter();
+    expect(adapter1).toBe(adapter2);
+  });
+});

package/tests/reasoningbank-adapter.test.ts

@@ -0,0 +1,219 @@
+/**
+ * @sparkleideas/browser - ReasoningBank Adapter Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ReasoningBankAdapter, getReasoningBank } from '../src/infrastructure/reasoningbank-adapter.js';
+import type { BrowserTrajectory } from '../src/domain/types.js';
+
+describe('ReasoningBankAdapter', () => {
+  let adapter: ReasoningBankAdapter;
+
+  beforeEach(() => {
+    adapter = new ReasoningBankAdapter();
+  });
+
+  describe('getReasoningBank singleton', () => {
+    it('should return singleton instance', () => {
+      const instance1 = getReasoningBank();
+      const instance2 = getReasoningBank();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('trajectory storage', () => {
+    const mockTrajectory: BrowserTrajectory = {
+      id: 'traj-1',
+      goal: 'Login to dashboard',
+      startUrl: 'https://example.com/login',
+      startTime: new Date().toISOString(),
+      endTime: new Date().toISOString(),
+      steps: [
+        {
+          action: 'open',
+          input: { url: 'https://example.com/login' },
+          result: { success: true, duration: 100 },
+          timestamp: new Date().toISOString(),
+        },
+        {
+          action: 'fill',
+          input: { target: '@e1', value: 'user@example.com' },
+          result: { success: true, duration: 50 },
+          timestamp: new Date().toISOString(),
+        },
+        {
+          action: 'fill',
+          input: { target: '@e2', value: 'password' },
+          result: { success: true, duration: 50 },
+          timestamp: new Date().toISOString(),
+        },
+        {
+          action: 'click',
+          input: { target: '@e3' },
+          result: { success: true, duration: 200 },
+          timestamp: new Date().toISOString(),
+        },
+      ],
+      success: true,
+      verdict: 'Login successful',
+    };
+
+    it('should store successful trajectory and extract pattern', async () => {
+      await adapter.storeTrajectory(mockTrajectory);
+
+      const stats = adapter.getStats();
+      expect(stats.totalPatterns).toBeGreaterThan(0);
+    });
+
+    it('should not create pattern from single-step trajectory', async () => {
+      const singleStepTrajectory: BrowserTrajectory = {
+        ...mockTrajectory,
+        id: 'traj-single',
+        steps: [mockTrajectory.steps[0]],
+      };
+
+      await adapter.storeTrajectory(singleStepTrajectory);
+
+      // Pattern extraction requires at least 2 steps
+      const patterns = adapter.exportPatterns();
+      const singlePattern = patterns.find(p => p.goal === singleStepTrajectory.goal && p.steps.length === 1);
+      expect(singlePattern).toBeUndefined();
+    });
+
+    it('should update existing pattern on repeated success', async () => {
+      await adapter.storeTrajectory(mockTrajectory);
+      await adapter.storeTrajectory(mockTrajectory);
+
+      const patterns = adapter.exportPatterns();
+      const pattern = patterns.find(p => p.goal === mockTrajectory.goal);
+
+      expect(pattern).toBeDefined();
+      expect(pattern?.usageCount).toBeGreaterThan(1);
+    });
+  });
+
+  describe('pattern matching', () => {
+    const mockTrajectory: BrowserTrajectory = {
+      id: 'traj-2',
+      goal: 'Fill contact form',
+      startUrl: 'https://example.com/contact',
+      startTime: new Date().toISOString(),
+      endTime: new Date().toISOString(),
+      steps: [
+        { action: 'fill', input: { target: '@e1', value: 'Name' }, result: { success: true, duration: 50 }, timestamp: new Date().toISOString() },
+        { action: 'fill', input: { target: '@e2', value: 'email' }, result: { success: true, duration: 50 }, timestamp: new Date().toISOString() },
+        { action: 'click', input: { target: '@e3' }, result: { success: true, duration: 100 }, timestamp: new Date().toISOString() },
+      ],
+      success: true,
+    };
+
+    it('should find similar patterns by goal', async () => {
+      await adapter.storeTrajectory(mockTrajectory);
+
+      const patterns = await adapter.findSimilarPatterns('contact form');
+
+      expect(Array.isArray(patterns)).toBe(true);
+    });
+
+    it('should return empty array for no matches', async () => {
+      const patterns = await adapter.findSimilarPatterns('completely unrelated xyz');
+
+      expect(patterns).toEqual([]);
+    });
+
+    it('should get recommended steps for similar goal', async () => {
+      await adapter.storeTrajectory(mockTrajectory);
+
+      const steps = await adapter.getRecommendedSteps('Fill a form');
+
+      expect(Array.isArray(steps)).toBe(true);
+    });
+  });
+
+  describe('verdict recording', () => {
+    it('should record verdict for trajectory', async () => {
+      const mockTrajectory: BrowserTrajectory = {
+        id: 'traj-3',
+        goal: 'Test pattern',
+        startUrl: 'https://example.com',
+        startTime: new Date().toISOString(),
+        endTime: new Date().toISOString(),
+        steps: [
+          { action: 'click', input: { target: '@e1' }, result: { success: true, duration: 100 }, timestamp: new Date().toISOString() },
+          { action: 'click', input: { target: '@e2' }, result: { success: true, duration: 100 }, timestamp: new Date().toISOString() },
+        ],
+        success: true,
+      };
+
+      await adapter.storeTrajectory(mockTrajectory);
+      await adapter.recordVerdict('traj-3', true, 'Works great');
+
+      // Just verify it doesn't throw
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('stats', () => {
+    it('should return stats with correct structure', () => {
+      const stats = adapter.getStats();
+
+      expect(stats).toHaveProperty('totalPatterns');
+      expect(stats).toHaveProperty('avgSuccessRate');
+      expect(stats).toHaveProperty('bufferedTrajectories');
+      expect(typeof stats.totalPatterns).toBe('number');
+      expect(typeof stats.avgSuccessRate).toBe('number');
+      expect(typeof stats.bufferedTrajectories).toBe('number');
+    });
+
+    it('should return zero patterns initially', () => {
+      const stats = adapter.getStats();
+
+      expect(stats.totalPatterns).toBe(0);
+      expect(stats.avgSuccessRate).toBe(0);
+    });
+  });
+
+  describe('pattern export/import', () => {
+    it('should export patterns as array', async () => {
+      const mockTrajectory: BrowserTrajectory = {
+        id: 'traj-4',
+        goal: 'Export test',
+        startUrl: 'https://example.com',
+        startTime: new Date().toISOString(),
+        endTime: new Date().toISOString(),
+        steps: [
+          { action: 'open', input: { url: 'https://example.com' }, result: { success: true, duration: 100 }, timestamp: new Date().toISOString() },
+          { action: 'click', input: { target: '@e1' }, result: { success: true, duration: 50 }, timestamp: new Date().toISOString() },
+        ],
+        success: true,
+      };
+
+      await adapter.storeTrajectory(mockTrajectory);
+
+      const patterns = adapter.exportPatterns();
+
+      expect(Array.isArray(patterns)).toBe(true);
+      expect(patterns.length).toBeGreaterThan(0);
+    });
+
+    it('should import patterns', () => {
+      const patternsToImport = [
+        {
+          id: 'imported-1',
+          type: 'navigation' as const,
+          goal: 'Imported pattern',
+          steps: [{ action: 'open' }],
+          successRate: 0.9,
+          avgDuration: 100,
+          lastUsed: new Date().toISOString(),
+          usageCount: 5,
+        },
+      ];
+
+      adapter.importPatterns(patternsToImport);
+
+      const stats = adapter.getStats();
+      expect(stats.totalPatterns).toBe(1);
+    });
+  });
+});

package/tests/security-integration.test.ts

@@ -0,0 +1,194 @@
+/**
+ * @sparkleideas/browser - Security Integration Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  BrowserSecurityScanner,
+  getSecurityScanner,
+  isUrlSafe,
+  containsPII,
+  type SecurityConfig,
+} from '../src/infrastructure/security-integration.js';
+
+describe('BrowserSecurityScanner', () => {
+  let scanner: BrowserSecurityScanner;
+
+  beforeEach(() => {
+    scanner = new BrowserSecurityScanner();
+  });
+
+  describe('scanUrl', () => {
+    it('should pass safe HTTPS URLs', async () => {
+      const result = await scanner.scanUrl('https://example.com');
+      expect(result.safe).toBe(true);
+      expect(result.score).toBeGreaterThan(0.7);
+    });
+
+    it('should warn about HTTP URLs when requireHttps is enabled', async () => {
+      const strictScanner = new BrowserSecurityScanner({ requireHttps: true });
+      const result = await strictScanner.scanUrl('http://example.com');
+      expect(result.threats.some(t => t.type === 'insecure-protocol')).toBe(true);
+    });
+
+    it('should detect blocked domains', async () => {
+      const result = await scanner.scanUrl('https://bit.ly/abcd123');
+      expect(result.threats.some(t => t.type === 'blocked-domain')).toBe(true);
+    });
+
+    it('should detect suspicious TLDs', async () => {
+      const result = await scanner.scanUrl('https://suspicious-site.xyz');
+      expect(result.threats.some(t => t.type === 'phishing')).toBe(true);
+    });
+
+    it('should detect IP address URLs', async () => {
+      const result = await scanner.scanUrl('https://192.168.1.1/login');
+      expect(result.threats.some(t => t.type === 'suspicious-redirect')).toBe(true);
+    });
+
+    it('should detect phishing indicators in URL', async () => {
+      const result = await scanner.scanUrl('https://secure-login-verify.example.com');
+      expect(result.threats.some(t => t.type === 'phishing')).toBe(true);
+    });
+
+    it('should allow domains in allowedDomains list', async () => {
+      const allowedScanner = new BrowserSecurityScanner({
+        allowedDomains: ['bit.ly'],
+      });
+      const result = await allowedScanner.scanUrl('https://bit.ly/safe');
+      expect(result.threats.some(t => t.type === 'blocked-domain')).toBe(false);
+    });
+  });
+
+  describe('scanContent', () => {
+    it('should detect email addresses', () => {
+      const result = scanner.scanContent('Contact us at test@example.com for help');
+      expect(result.pii.some(p => p.type === 'email')).toBe(true);
+    });
+
+    it('should detect phone numbers', () => {
+      const result = scanner.scanContent('Call us at 555-123-4567');
+      expect(result.pii.some(p => p.type === 'phone')).toBe(true);
+    });
+
+    it('should detect SSNs', () => {
+      const result = scanner.scanContent('SSN: 123-45-6789');
+      expect(result.pii.some(p => p.type === 'ssn')).toBe(true);
+    });
+
+    it('should detect credit card numbers', () => {
+      const result = scanner.scanContent('Card: 4111-1111-1111-1111');
+      expect(result.pii.some(p => p.type === 'credit-card')).toBe(true);
+    });
+
+    it('should detect API keys', () => {
+      // API key pattern: sk- or sk_ followed by 20+ alphanumeric chars
+      const result = scanner.scanContent('API Key: sk_abcdefghij1234567890abc');
+      expect(result.pii.some(p => p.type === 'api-key')).toBe(true);
+    });
+
+    it('should add threat for sensitive PII', () => {
+      const result = scanner.scanContent('SSN: 123-45-6789, Card: 4111-1111-1111-1111');
+      expect(result.threats.some(t => t.type === 'data-exfiltration')).toBe(true);
+    });
+
+    it('should return safe for content without PII', () => {
+      const result = scanner.scanContent('This is just regular text content');
+      expect(result.pii.length).toBe(0);
+      expect(result.safe).toBe(true);
+    });
+  });
+
+  describe('validateInput', () => {
+    it('should detect SQL injection patterns', () => {
+      const result = scanner.validateInput("'; DROP TABLE users; --", 'username');
+      expect(result.threats.some(t => t.type === 'injection')).toBe(true);
+    });
+
+    it('should detect XSS patterns', () => {
+      const result = scanner.validateInput('<script>alert("xss")</script>', 'comment');
+      expect(result.threats.some(t => t.type === 'xss')).toBe(true);
+    });
+
+    it('should detect event handler XSS', () => {
+      const result = scanner.validateInput('<img src="x" onerror="alert(1)">', 'bio');
+      expect(result.threats.some(t => t.type === 'xss')).toBe(true);
+    });
+
+    it('should pass safe input', () => {
+      const result = scanner.validateInput('Hello, World!', 'message');
+      expect(result.safe).toBe(true);
+    });
+  });
+
+  describe('sanitizeInput', () => {
+    it('should escape HTML entities', () => {
+      const result = scanner.sanitizeInput('<script>alert("xss")</script>');
+      expect(result).not.toContain('<script>');
+      expect(result).toContain('&lt;');
+      expect(result).toContain('&gt;');
+    });
+
+    it('should remove script tags', () => {
+      const result = scanner.sanitizeInput('Hello <script>evil()</script> World');
+      expect(result).not.toContain('<script>');
+    });
+
+    it('should escape HTML entities', () => {
+      const result = scanner.sanitizeInput('<div onclick="evil()">click me</div>');
+      // The sanitizer escapes HTML entities (which also neutralizes event handlers)
+      expect(result).toContain('&lt;div');
+      expect(result).toContain('&gt;');
+    });
+  });
+
+  describe('maskPII', () => {
+    it('should mask email addresses', () => {
+      const result = scanner.maskPII('test@example.com', 'email');
+      expect(result).toMatch(/t\*+@example\.com/);
+    });
+
+    it('should mask phone numbers', () => {
+      const result = scanner.maskPII('5551234567', 'phone');
+      // The phone masking leaves the last 4 digits visible
+      expect(result.endsWith('4567')).toBe(true);
+    });
+
+    it('should mask SSNs', () => {
+      const result = scanner.maskPII('123-45-6789', 'ssn');
+      expect(result).toBe('***-**-6789');
+    });
+
+    it('should mask credit card numbers', () => {
+      const result = scanner.maskPII('4111111111111111', 'credit-card');
+      expect(result).toMatch(/\*+ 1111$/);
+    });
+
+    it('should mask API keys', () => {
+      const result = scanner.maskPII('sk_live_1234567890abcdefghij', 'api-key');
+      expect(result).toMatch(/^sk_live_\*+/);
+    });
+
+    it('should completely mask passwords', () => {
+      const result = scanner.maskPII('secretpassword', 'password');
+      expect(result).toBe('********');
+    });
+  });
+});
+
+describe('factory functions', () => {
+  it('getSecurityScanner should return scanner', () => {
+    const scanner = getSecurityScanner();
+    expect(scanner).toBeInstanceOf(BrowserSecurityScanner);
+  });
+
+  it('isUrlSafe should return boolean', async () => {
+    const result = await isUrlSafe('https://example.com');
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('containsPII should detect PII', () => {
+    expect(containsPII('My email is test@example.com')).toBe(true);
+    expect(containsPII('Hello World')).toBe(false);
+  });
+});