Agent Police Department v1.0.0 MVP

2026-06-14 13:18:56 +00:00
commit 672e9ef17c
30 changed files with 7619 additions and 0 deletions
@@ -0,0 +1,583 @@
+// test-runner.js — Simple test runner that doesn't require Jest
+
+const fs = require('fs');
+const path = require('path');
+
+// Mock chrome APIs
+global.chrome = {
+  storage: {
+    local: {
+      get: async (keys) => {
+        const store = {};
+        if (typeof keys === 'string') keys = [keys];
+        for (const key of keys) {
+          store[key] = global.__chromeStore?.[key] ?? undefined;
+        }
+        return store;
+      },
+      set: async (items) => {
+        global.__chromeStore = { ...global.__chromeStore, ...items };
+      },
+      remove: async (keys) => {
+        if (typeof keys === 'string') keys = [keys];
+        for (const key of keys) delete global.__chromeStore?.[key];
+      },
+      clear: async () => {
+        global.__chromeStore = {};
+      }
+    }
+  },
+  runtime: {
+    getManifest: () => ({ version: '1.0.0' })
+  },
+  action: {
+    setBadgeText: async () => {},
+    setBadgeBackgroundColor: async () => {}
+  }
+};
+
+global.__chromeStore = {};
+
+let testsPassed = 0;
+let testsFailed = 0;
+const failures = [];
+
+function test(name, fn) {
+  global.__chromeStore = {};
+  try {
+    fn();
+    testsPassed++;
+    console.log(`  ✓ ${name}`);
+  } catch (err) {
+    testsFailed++;
+    failures.push({ name, error: err.message });
+    console.log(`  ✗ ${name}`);
+    console.log(`    ${err.message}`);
+  }
+}
+
+function expect(actual) {
+  return {
+    toBe(expected) {
+      if (actual !== expected) {
+        throw new Error(`Expected ${JSON.stringify(expected)} but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toEqual(expected) {
+      const a = JSON.stringify(actual);
+      const e = JSON.stringify(expected);
+      if (a !== e) {
+        throw new Error(`Expected ${e} but got ${a}`);
+      }
+    },
+    toBeDefined() {
+      if (actual === undefined) {
+        throw new Error(`Expected value to be defined but got undefined`);
+      }
+    },
+    toBeUndefined() {
+      if (actual !== undefined) {
+        throw new Error(`Expected value to be undefined but got ${JSON.stringify(actual)}`);
+      }
+    },
+    toHaveLength(expected) {
+      if (actual.length !== expected) {
+        throw new Error(`Expected length ${expected} but got ${actual.length}`);
+      }
+    },
+    toContain(expected) {
+      if (!actual.includes(expected)) {
+        throw new Error(`Expected array to contain ${JSON.stringify(expected)}`);
+      }
+    },
+    toMatch(pattern) {
+      if (!pattern.test(actual)) {
+        throw new Error(`Expected ${JSON.stringify(actual)} to match ${pattern}`);
+      }
+    },
+    toBeGreaterThan(expected) {
+      if (actual <= expected) {
+        throw new Error(`Expected ${JSON.stringify(actual)} to be greater than ${JSON.stringify(expected)}`);
+      }
+    },
+    toBeLessThan(expected) {
+      if (actual >= expected) {
+        throw new Error(`Expected ${JSON.stringify(actual)} to be less than ${JSON.stringify(expected)}`);
+      }
+    },
+    toBeLessThanOrEqual(expected) {
+      if (actual > expected) {
+        throw new Error(`Expected ${JSON.stringify(actual)} to be less than or equal to ${JSON.stringify(expected)}`);
+      }
+    },
+    not: {
+      toBe(expected) {
+        if (actual === expected) {
+          throw new Error(`Expected values to differ but both were ${JSON.stringify(expected)}`);
+        }
+      }
+    }
+  };
+}
+
+async function runAsyncTest(name, fn) {
+  global.__chromeStore = {};
+  try {
+    await fn();
+    testsPassed++;
+    console.log(`  ✓ ${name}`);
+  } catch (err) {
+    testsFailed++;
+    failures.push({ name, error: err.message });
+    console.log(`  ✗ ${name}`);
+    console.log(`    ${err.message}`);
+  }
+}
+
+// Module cache for loaded modules
+const moduleCache = {};
+
+// Helper to load ES modules by converting them to CommonJS
+function loadModule(filePath) {
+  const absPath = path.resolve(filePath);
+  if (moduleCache[absPath]) return moduleCache[absPath];
+  
+  const content = fs.readFileSync(absPath, 'utf-8');
+  const dir = path.dirname(absPath);
+  
+  // Track exported names
+  const exportedNames = [];
+  
+  // Convert ES module imports to requires
+  let modified = content;
+  
+  // Replace import { a, b } from './file.js' with const { a, b } = require('./file.js')
+  modified = modified.replace(
+    /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"];?/g,
+    (match, imports, source) => {
+      const cleanSource = source.replace(/\.js$/, '');
+      return `const { ${imports} } = require('${cleanSource}');`;
+    }
+  );
+  
+  // Replace import * as name from './file.js' with const name = require('./file.js')
+  modified = modified.replace(
+    /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"];?/g,
+    (match, name, source) => {
+      const cleanSource = source.replace(/\.js$/, '');
+      return `const ${name} = require('${cleanSource}');`;
+    }
+  );
+  
+  // Replace import name from './file.js' with const name = require('./file.js')
+  modified = modified.replace(
+    /import\s+(\w+)\s+from\s*['"]([^'"]+)['"];?/g,
+    (match, name, source) => {
+      const cleanSource = source.replace(/\.js$/, '');
+      return `const ${name} = require('${cleanSource}');`;
+    }
+  );
+  
+  // Convert export function to function + track export
+  modified = modified.replace(/export\s+async\s+function\s+(\w+)/g, (match, name) => {
+    exportedNames.push(name);
+    return `async function ${name}`;
+  });
+  modified = modified.replace(/export\s+function\s+(\w+)/g, (match, name) => {
+    exportedNames.push(name);
+    return `function ${name}`;
+  });
+  
+  // Convert export const to const + track export
+  modified = modified.replace(/export\s+const\s+(\w+)/g, (match, name) => {
+    exportedNames.push(name);
+    return `const ${name}`;
+  });
+  
+  // Convert export { a, b } to module.exports = { a, b }
+  modified = modified.replace(
+    /export\s*\{([^}]+)\};?/g,
+    (match, names) => {
+      const assignments = names.split(',').map(n => n.trim()).filter(Boolean).map(n => {
+        const [orig, alias] = n.split(' as ').map(s => s.trim());
+        exportedNames.push(alias || orig);
+        return `${alias || orig}: ${orig}`;
+      });
+      return `module.exports = { ${assignments.join(', ')} };`;
+    }
+  );
+  
+  // Add module.exports for tracked exports at the end if not already present
+  if (!modified.includes('module.exports') && exportedNames.length > 0) {
+    const uniqueExports = [...new Set(exportedNames)];
+    const exportsStr = uniqueExports.map(n => `${n}: ${n}`).join(', ');
+    modified += `\nmodule.exports = { ${exportsStr} };\n`;
+  }
+  
+  // Create a custom require function that resolves relative paths
+  const customRequire = (id) => {
+    if (id.startsWith('.')) {
+      const base = id.endsWith('.js') ? id : id + '.js';
+      const resolved = path.resolve(dir, base);
+      return loadModule(resolved);
+    }
+    return require(id);
+  };
+  
+  const moduleObj = { exports: {} };
+  const fn = new Function('module', 'exports', 'require', 'console', 'crypto', 'global', modified);
+  fn(moduleObj, moduleObj.exports, customRequire, console, globalThis.crypto, global);
+  
+  moduleCache[absPath] = moduleObj.exports;
+  return moduleObj.exports;
+}
+
+async function main() {
+  console.log('Agent Police Department Test Runner\n');
+  
+  const buildDir = __dirname;
+  
+  // Load modules in dependency order
+  const hashMod = loadModule(path.join(buildDir, 'lib/hash.js'));
+  const { hashEvent, hashChain, sha256Async } = hashMod;
+  
+  const policyMod = loadModule(path.join(buildDir, 'lib/policy.js'));
+  const { loadPolicy, savePolicy, checkPolicy } = policyMod;
+  
+  const auditMod = loadModule(path.join(buildDir, 'lib/audit.js'));
+  const { addEvent, addViolation, getStats, getAuditLog, getViolations, exportAuditLog, searchAuditLog, verifyIntegrity } = auditMod;
+  
+  // Hash tests
+  console.log('Hash Tests');
+  test('hashEvent returns consistent hash', () => {
+    const event = { id: 'e1', type: 'tool_use' };
+    const h1 = hashEvent(event);
+    const h2 = hashEvent(event);
+    expect(h1).toBe(h2);
+    expect(h1.length).toBeGreaterThan(0);
+  });
+  
+  test('hashEvent returns different hash for different events', () => {
+    const h1 = hashEvent({ id: 'e1', type: 'tool_use' });
+    const h2 = hashEvent({ id: 'e2', type: 'api_call' });
+    expect(h1).not.toBe(h2);
+  });
+  
+  test('hashChain returns empty for empty array', () => {
+    expect(hashChain([])).toBe('');
+  });
+  
+  test('hashChain returns hash for events', () => {
+    const chain = hashChain([{ id: 'e1' }, { id: 'e2' }]);
+    expect(chain.length).toBeGreaterThan(0);
+  });
+  
+  test('hashChain is order-sensitive', () => {
+    const chain1 = hashChain([{ id: 'e1' }, { id: 'e2' }]);
+    const chain2 = hashChain([{ id: 'e2' }, { id: 'e1' }]);
+    expect(chain1).not.toBe(chain2);
+  });
+  
+  await runAsyncTest('sha256Async returns hex string', async () => {
+    const hash = await sha256Async('hello');
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+  
+  // Policy tests
+  console.log('\nPolicy Tests');
+  await runAsyncTest('loadPolicy returns default policy when none stored', async () => {
+    const policy = await loadPolicy();
+    expect(policy).toBeDefined();
+    expect(policy.version).toBe(1);
+    expect(policy.rules).toHaveLength(6);
+  });
+  
+  await runAsyncTest('savePolicy increments version', async () => {
+    const policy = await loadPolicy();
+    const saved = await savePolicy(policy);
+    expect(saved.version).toBe(2);
+  });
+  
+  test('checkPolicy allows permitted domains', () => {
+    const event = {
+      type: 'api_call',
+      tool: 'fetch',
+      target: 'https://github.com/api',
+      url: 'https://claude.ai/chat'
+    };
+    const policy = {
+      rules: [
+        { id: 'rule1', type: 'allowed_domains', enabled: true, params: { domains: ['github.com'] } }
+      ]
+    };
+    const result = checkPolicy(event, policy);
+    expect(result.outcome).toBe('allowed');
+    expect(result.severity).toBe('info');
+  });
+  
+  test('checkPolicy flags disallowed domains', () => {
+    const event = {
+      type: 'api_call',
+      tool: 'fetch',
+      target: 'https://evil.com/api',
+      url: 'https://claude.ai/chat'
+    };
+    const policy = {
+      rules: [
+        { id: 'rule1', type: 'allowed_domains', enabled: true, params: { domains: ['github.com'] } }
+      ]
+    };
+    const result = checkPolicy(event, policy);
+    expect(result.outcome).toBe('violation');
+    expect(result.severity).toBe('high');
+    expect(result.ruleId).toBe('rule1');
+  });
+  
+  test('checkPolicy flags disallowed tools', () => {
+    const event = {
+      type: 'tool_use',
+      tool: 'eval',
+      target: 'script.js',
+      url: 'https://claude.ai/chat'
+    };
+    const policy = {
+      rules: [
+        { id: 'rule1', type: 'disallowed_tools', enabled: true, params: { tools: ['eval'] } }
+      ]
+    };
+    const result = checkPolicy(event, policy);
+    expect(result.outcome).toBe('violation');
+    expect(result.severity).toBe('critical');
+  });
+  
+  test('disabled rules are ignored', () => {
+    const event = {
+      type: 'tool_use',
+      tool: 'eval',
+      target: 'script.js',
+      url: 'https://claude.ai/chat'
+    };
+    const policy = {
+      rules: [
+        { id: 'rule1', type: 'disallowed_tools', enabled: false, params: { tools: ['eval'] } }
+      ]
+    };
+    const result = checkPolicy(event, policy);
+    expect(result.outcome).toBe('allowed');
+  });
+  
+  // Audit tests
+  console.log('\nAudit Tests');
+  await runAsyncTest('addEvent stores event', async () => {
+    const event = { id: 'e1', type: 'tool_use', timestamp: new Date().toISOString() };
+    await addEvent(event);
+    const log = await getAuditLog(10);
+    expect(log).toHaveLength(1);
+    expect(log[0].id).toBe('e1');
+  });
+  
+  await runAsyncTest('addViolation stores violation', async () => {
+    const violation = { id: 'v1', event_id: 'e1', detector: 'disallowed_tools', severity: 'critical', timestamp: new Date().toISOString() };
+    await addViolation(violation);
+    const list = await getViolations(10);
+    expect(list).toHaveLength(1);
+    expect(list[0].severity).toBe('critical');
+  });
+  
+  await runAsyncTest('getStats returns correct counts', async () => {
+    await addEvent({ id: 'e1', type: 'tool_use', timestamp: new Date().toISOString() });
+    await addEvent({ id: 'e2', type: 'api_call', timestamp: new Date().toISOString() });
+    await addViolation({ id: 'v1', event_id: 'e1', detector: 'disallowed_tools', severity: 'high', timestamp: new Date().toISOString() });
+    const stats = await getStats();
+    expect(stats.totalEvents).toBe(2);
+    expect(stats.totalViolations).toBe(1);
+    expect(stats.severityCounts.high).toBe(1);
+  });
+  
+  await runAsyncTest('exportAuditLog includes integrity hash', async () => {
+    await addEvent({ id: 'e1', type: 'tool_use', timestamp: new Date().toISOString() });
+    const exported = await exportAuditLog();
+    expect(exported.totalEvents).toBe(1);
+    expect(exported.integrity).toBeDefined();
+    expect(exported.integrity.length).toBeGreaterThan(0);
+  });
+  
+  await runAsyncTest('searchAuditLog filters by query', async () => {
+    await addEvent({ id: 'e1', type: 'tool_use', tool: 'read_file', target: 'app.js', timestamp: new Date().toISOString() });
+    await addEvent({ id: 'e2', type: 'tool_use', tool: 'edit_file', target: 'config.js', timestamp: new Date().toISOString() });
+    const results = await searchAuditLog('config');
+    expect(results).toHaveLength(1);
+    expect(results[0].target).toBe('config.js');
+  });
+  
+  await runAsyncTest('verifyIntegrity returns valid for empty log', async () => {
+    const result = await verifyIntegrity();
+    expect(result.valid).toBe(true);
+    expect(result.eventsChecked).toBe(0);
+  });
+  
+  await runAsyncTest('max events limit enforced', async () => {
+    for (let i = 0; i < 1100; i++) {
+      await addEvent({ id: `e${i}`, type: 'tool_use', timestamp: new Date().toISOString() });
+    }
+    const log = await getAuditLog(2000);
+    expect(log.length).toBeLessThanOrEqual(1000);
+  });
+  
+  // Detectors tests
+  console.log('\nDetectors Tests');
+  const detectorsMod = loadModule(path.join(buildDir, 'lib/detectors.js'));
+  const { detectViolations, DETECTOR_NAMES } = detectorsMod;
+  
+  test('DETECTOR_NAMES has 6 detectors', () => {
+    expect(DETECTOR_NAMES).toHaveLength(6);
+    expect(DETECTOR_NAMES).toContain('permission_bypass');
+    expect(DETECTOR_NAMES).toContain('out_of_scope');
+    expect(DETECTOR_NAMES).toContain('self_permissioning');
+    expect(DETECTOR_NAMES).toContain('disallowed_tools');
+    expect(DETECTOR_NAMES).toContain('redundant_operations');
+    expect(DETECTOR_NAMES).toContain('off_task');
+  });
+  
+  await runAsyncTest('detects permission bypass for disallowed domain', async () => {
+    const event = {
+      id: 'evt-1',
+      type: 'api_call',
+      tool: 'fetch',
+      target: 'https://malicious.com/api',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_allowed_domains', type: 'allowed_domains', enabled: true, params: { domains: ['github.com', 'claude.ai'] } }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    const bypass = violations.find(v => v.detector === 'permission_bypass');
+    expect(bypass).toBeDefined();
+    expect(bypass.severity).toBe('high');
+    expect(bypass.message).toContain('malicious.com');
+  });
+  
+  await runAsyncTest('allows permitted domain', async () => {
+    const event = {
+      id: 'evt-2',
+      type: 'api_call',
+      tool: 'fetch',
+      target: 'https://github.com/api',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_allowed_domains', type: 'allowed_domains', enabled: true, params: { domains: ['github.com'] } }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    const bypass = violations.find(v => v.detector === 'permission_bypass');
+    expect(bypass).toBeUndefined();
+  });
+  
+  await runAsyncTest('detects disallowed tools', async () => {
+    const event = {
+      id: 'evt-3',
+      type: 'tool_use',
+      tool: 'eval',
+      target: 'some-script.js',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_disallowed_tools', type: 'disallowed_tools', enabled: true, params: { tools: ['eval', 'exec'] } }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    const disallowed = violations.find(v => v.detector === 'disallowed_tools');
+    expect(disallowed).toBeDefined();
+    expect(disallowed.severity).toBe('critical');
+    expect(disallowed.message).toContain('eval');
+  });
+  
+  await runAsyncTest('detects self-permissioning', async () => {
+    const event = {
+      id: 'evt-4',
+      type: 'tool_use',
+      tool: 'edit_file',
+      target: 'permissions.json',
+      context: 'grant admin access control role privilege',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_permission_change', type: 'permission_change', enabled: true, params: {} }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    const perm = violations.find(v => v.detector === 'self_permissioning');
+    expect(perm).toBeDefined();
+    expect(perm.severity).toBe('critical');
+  });
+  
+  await runAsyncTest('detects out-of-scope operations', async () => {
+    const event = {
+      id: 'evt-5',
+      type: 'api_call',
+      tool: 'delete',
+      target: 'https://api.example.com/resource',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_allowed_operations', type: 'allowed_operations', enabled: true, params: { operations: ['read', 'chat'] } }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    const scope = violations.find(v => v.detector === 'out_of_scope');
+    expect(scope).toBeDefined();
+    expect(scope.severity).toBe('medium');
+  });
+  
+  await runAsyncTest('no violations for normal activity', async () => {
+    const event = {
+      id: 'evt-6',
+      type: 'chat',
+      tool: 'chat',
+      target: 'conversation',
+      url: 'https://claude.ai/chat',
+      timestamp: new Date().toISOString()
+    };
+    const policy = {
+      rules: [
+        { id: 'rule_allowed_domains', type: 'allowed_domains', enabled: true, params: { domains: ['claude.ai'] } },
+        { id: 'rule_disallowed_tools', type: 'disallowed_tools', enabled: true, params: { tools: ['eval'] } }
+      ]
+    };
+    const violations = await detectViolations(event, policy);
+    expect(violations).toHaveLength(0);
+  });
+  
+  // Summary
+  console.log('\n' + '='.repeat(50));
+  console.log(`Results: ${testsPassed} passed, ${testsFailed} failed`);
+  console.log('='.repeat(50));
+  
+  if (testsFailed > 0) {
+    console.log('\nFailures:');
+    for (const f of failures) {
+      console.log(`  - ${f.name}: ${f.error}`);
+    }
+    process.exit(1);
+  } else {
+    console.log('\n✓ All tests passed');
+    process.exit(0);
+  }
+}
+
+main().catch(err => {
+  console.error('Test runner failed:', err);
+  process.exit(1);
+});