opc-agent 4.0.44 → 4.1.1

package/tests/elevated.test.ts

@@ -1,69 +1,69 @@
-import { describe, it, expect } from 'vitest';
-import { ElevatedManager } from '../src/security/elevated';
-
-describe('ElevatedManager', () => {
-  it('should default to ask mode', () => {
-    const mgr = new ElevatedManager();
-    expect(mgr.getMode()).toBe('ask');
-    expect(mgr.isElevated()).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should elevate and revoke', () => {
-    const mgr = new ElevatedManager();
-    expect(mgr.elevate('test')).toBe(true);
-    expect(mgr.isElevated()).toBe(true);
-    mgr.revoke();
-    expect(mgr.isElevated()).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should not elevate in off mode', () => {
-    const mgr = new ElevatedManager({ mode: 'off' });
-    expect(mgr.elevate()).toBe(false);
-    expect(mgr.isElevated()).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should allow commands in allowedCommands list', () => {
-    const mgr = new ElevatedManager({ allowedCommands: [/^git\s/] });
-    expect(mgr.isCommandAllowed('git pull')).toBe(true);
-    expect(mgr.isCommandAllowed('rm -rf /')).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should auto-execute in on mode', () => {
-    const mgr = new ElevatedManager({ mode: 'on' });
-    const result = mgr.canExecute('sudo reboot');
-    expect(result.allowed).toBe(true);
-    expect(mgr.isElevated()).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should require elevation in ask mode when not elevated', () => {
-    const mgr = new ElevatedManager({ mode: 'ask' });
-    const result = mgr.canExecute('sudo reboot');
-    expect(result.allowed).toBe(false);
-    expect(result.needsElevation).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should allow execution in ask mode when elevated', () => {
-    const mgr = new ElevatedManager({ mode: 'ask' });
-    mgr.elevate();
-    const result = mgr.canExecute('sudo reboot');
-    expect(result.allowed).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should keep audit log', () => {
-    const mgr = new ElevatedManager();
-    mgr.elevate('testing');
-    mgr.revoke('done');
-    const log = mgr.getAuditLog();
-    expect(log).toHaveLength(2);
-    expect(log[0].action).toBe('elevate');
-    expect(log[1].action).toBe('revoke');
-    mgr.destroy();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ElevatedManager } from '../src/security/elevated';
+
+describe('ElevatedManager', () => {
+  it('should default to ask mode', () => {
+    const mgr = new ElevatedManager();
+    expect(mgr.getMode()).toBe('ask');
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should elevate and revoke', () => {
+    const mgr = new ElevatedManager();
+    expect(mgr.elevate('test')).toBe(true);
+    expect(mgr.isElevated()).toBe(true);
+    mgr.revoke();
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should not elevate in off mode', () => {
+    const mgr = new ElevatedManager({ mode: 'off' });
+    expect(mgr.elevate()).toBe(false);
+    expect(mgr.isElevated()).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should allow commands in allowedCommands list', () => {
+    const mgr = new ElevatedManager({ allowedCommands: [/^git\s/] });
+    expect(mgr.isCommandAllowed('git pull')).toBe(true);
+    expect(mgr.isCommandAllowed('rm -rf /')).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should auto-execute in on mode', () => {
+    const mgr = new ElevatedManager({ mode: 'on' });
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(true);
+    expect(mgr.isElevated()).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should require elevation in ask mode when not elevated', () => {
+    const mgr = new ElevatedManager({ mode: 'ask' });
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(false);
+    expect(result.needsElevation).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should allow execution in ask mode when elevated', () => {
+    const mgr = new ElevatedManager({ mode: 'ask' });
+    mgr.elevate();
+    const result = mgr.canExecute('sudo reboot');
+    expect(result.allowed).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should keep audit log', () => {
+    const mgr = new ElevatedManager();
+    mgr.elevate('testing');
+    mgr.revoke('done');
+    const log = mgr.getAuditLog();
+    expect(log).toHaveLength(2);
+    expect(log[0].action).toBe('elevate');
+    expect(log[1].action).toBe('revoke');
+    mgr.destroy();
+  });
+});

package/tests/eval.test.ts

@@ -1,173 +1,173 @@
-import { describe, it, expect } from 'vitest';
-import { AgentEvaluator } from '../src/eval';
-import type { EvalCase, EvalSuite, EvalReport } from '../src/eval';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-
-// Mock agent
-const mockAgent = {
-  chat: async (input: string) => {
-    if (!input) return 'Hello! How can I help?';
-    if (input.includes('capital of France')) return 'The capital of France is Paris.';
-    if (input.includes('Hello')) return 'Hello there! How can I help you?';
-    return `Response to: ${input}`;
-  },
-};
-
-describe('AgentEvaluator', () => {
-  const evaluator = new AgentEvaluator(mockAgent);
-
-  it('should score exact match correctly', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-1',
-      input: 'What is the capital of France?',
-      expectedOutput: 'The capital of France is Paris.',
-    });
-    expect(result.scores.exact_match).toBe(1);
-    expect(result.passed).toBe(true);
-  });
-
-  it('should score exact match failure', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-2',
-      input: 'Hello!',
-      expectedOutput: 'Goodbye!',
-    });
-    expect(result.scores.exact_match).toBe(0);
-    expect(result.passed).toBe(false);
-  });
-
-  it('should score contains correctly', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-3',
-      input: 'What is the capital of France?',
-      expectedContains: ['Paris', 'capital'],
-    });
-    expect(result.scores.contains).toBe(1);
-    expect(result.passed).toBe(true);
-  });
-
-  it('should score partial contains', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-4',
-      input: 'What is the capital of France?',
-      expectedContains: ['Paris', 'London'],
-    });
-    expect(result.scores.contains).toBe(0.5);
-    expect(result.passed).toBe(true); // 0.5 >= 0.5 threshold
-  });
-
-  it('should score not_contains correctly', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-5',
-      input: 'Hello!',
-      expectedNotContains: ['error', 'crash'],
-    });
-    expect(result.scores.not_contains).toBe(1);
-    expect(result.passed).toBe(true);
-  });
-
-  it('should score not_contains failure', async () => {
-    const result = await evaluator.evalCase({
-      id: 'test-6',
-      input: 'Hello!',
-      expectedNotContains: ['Hello', 'crash'],
-    });
-    expect(result.scores.not_contains).toBe(0.5);
-  });
-
-  it('should load suite from JSON', () => {
-    const suitePath = path.join(__dirname, '..', 'src', 'eval', 'suites', 'basic.json');
-    const suite = AgentEvaluator.loadSuite(suitePath);
-    expect(suite.name).toBe('basic');
-    expect(suite.cases.length).toBe(10);
-  });
-
-  it('should load all built-in suites', () => {
-    const suites = AgentEvaluator.builtinSuites();
-    expect(suites.length).toBeGreaterThanOrEqual(3);
-    const names = suites.map(s => s.name);
-    expect(names).toContain('basic');
-    expect(names).toContain('safety');
-    expect(names).toContain('memory');
-  });
-
-  it('should have correct case counts for built-in suites', () => {
-    const suites = AgentEvaluator.builtinSuites();
-    const basic = suites.find(s => s.name === 'basic');
-    const safety = suites.find(s => s.name === 'safety');
-    const memory = suites.find(s => s.name === 'memory');
-    expect(basic?.caseCount).toBe(10);
-    expect(safety?.caseCount).toBe(8);
-    expect(memory?.caseCount).toBe(6);
-  });
-
-  it('should compare reports and detect regression', () => {
-    const baseline: EvalReport = {
-      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
-      results: [
-        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-      ],
-    };
-    const current: EvalReport = {
-      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
-      results: [
-        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
-      ],
-    };
-    const cmp = AgentEvaluator.compare(baseline, current);
-    expect(cmp.regressed).toContain('b');
-    expect(cmp.delta).toBe(-0.5);
-  });
-
-  it('should compare reports and detect improvement', () => {
-    const baseline: EvalReport = {
-      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
-      results: [
-        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
-      ],
-    };
-    const current: EvalReport = {
-      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
-      results: [
-        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
-      ],
-    };
-    const cmp = AgentEvaluator.compare(baseline, current);
-    expect(cmp.improved).toContain('b');
-    expect(cmp.delta).toBe(0.5);
-  });
-
-  it('should save and load report', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eval-'));
-    const reportPath = path.join(tmpDir, 'report.json');
-    const report: EvalReport = {
-      suite: 'test', timestamp: new Date().toISOString(), totalCases: 1, passed: 1, failed: 0, passRate: 1, avgLatency: 5, p95Latency: 5, summary: 'ok',
-      results: [{ caseId: 'x', input: 'hi', output: 'hello', scores: { latency_ms: 5 }, passed: true }],
-    };
-    AgentEvaluator.saveReport(report, reportPath);
-    const loaded = JSON.parse(fs.readFileSync(reportPath, 'utf-8'));
-    expect(loaded.suite).toBe('test');
-    expect(loaded.results.length).toBe(1);
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it('should run evalSuite and produce report', async () => {
-    const suite: EvalSuite = {
-      name: 'mini',
-      cases: [
-        { id: 't1', input: 'Hello!', expectedContains: ['hello', 'hi'] },
-        { id: 't2', input: 'What is the capital of France?', expectedContains: ['Paris'] },
-      ],
-    };
-    const report = await evaluator.evalSuite(suite);
-    expect(report.totalCases).toBe(2);
-    expect(report.passRate).toBeGreaterThanOrEqual(0);
-    expect(report.summary).toContain('mini');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { AgentEvaluator } from '../src/eval';
+import type { EvalCase, EvalSuite, EvalReport } from '../src/eval';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+
+// Mock agent
+const mockAgent = {
+  chat: async (input: string) => {
+    if (!input) return 'Hello! How can I help?';
+    if (input.includes('capital of France')) return 'The capital of France is Paris.';
+    if (input.includes('Hello')) return 'Hello there! How can I help you?';
+    return `Response to: ${input}`;
+  },
+};
+
+describe('AgentEvaluator', () => {
+  const evaluator = new AgentEvaluator(mockAgent);
+
+  it('should score exact match correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-1',
+      input: 'What is the capital of France?',
+      expectedOutput: 'The capital of France is Paris.',
+    });
+    expect(result.scores.exact_match).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score exact match failure', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-2',
+      input: 'Hello!',
+      expectedOutput: 'Goodbye!',
+    });
+    expect(result.scores.exact_match).toBe(0);
+    expect(result.passed).toBe(false);
+  });
+
+  it('should score contains correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-3',
+      input: 'What is the capital of France?',
+      expectedContains: ['Paris', 'capital'],
+    });
+    expect(result.scores.contains).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score partial contains', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-4',
+      input: 'What is the capital of France?',
+      expectedContains: ['Paris', 'London'],
+    });
+    expect(result.scores.contains).toBe(0.5);
+    expect(result.passed).toBe(true); // 0.5 >= 0.5 threshold
+  });
+
+  it('should score not_contains correctly', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-5',
+      input: 'Hello!',
+      expectedNotContains: ['error', 'crash'],
+    });
+    expect(result.scores.not_contains).toBe(1);
+    expect(result.passed).toBe(true);
+  });
+
+  it('should score not_contains failure', async () => {
+    const result = await evaluator.evalCase({
+      id: 'test-6',
+      input: 'Hello!',
+      expectedNotContains: ['Hello', 'crash'],
+    });
+    expect(result.scores.not_contains).toBe(0.5);
+  });
+
+  it('should load suite from JSON', () => {
+    const suitePath = path.join(__dirname, '..', 'src', 'eval', 'suites', 'basic.json');
+    const suite = AgentEvaluator.loadSuite(suitePath);
+    expect(suite.name).toBe('basic');
+    expect(suite.cases.length).toBe(10);
+  });
+
+  it('should load all built-in suites', () => {
+    const suites = AgentEvaluator.builtinSuites();
+    expect(suites.length).toBeGreaterThanOrEqual(3);
+    const names = suites.map(s => s.name);
+    expect(names).toContain('basic');
+    expect(names).toContain('safety');
+    expect(names).toContain('memory');
+  });
+
+  it('should have correct case counts for built-in suites', () => {
+    const suites = AgentEvaluator.builtinSuites();
+    const basic = suites.find(s => s.name === 'basic');
+    const safety = suites.find(s => s.name === 'safety');
+    const memory = suites.find(s => s.name === 'memory');
+    expect(basic?.caseCount).toBe(10);
+    expect(safety?.caseCount).toBe(8);
+    expect(memory?.caseCount).toBe(6);
+  });
+
+  it('should compare reports and detect regression', () => {
+    const baseline: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+      ],
+    };
+    const current: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
+      ],
+    };
+    const cmp = AgentEvaluator.compare(baseline, current);
+    expect(cmp.regressed).toContain('b');
+    expect(cmp.delta).toBe(-0.5);
+  });
+
+  it('should compare reports and detect improvement', () => {
+    const baseline: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 1, failed: 1, passRate: 0.5, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: false },
+      ],
+    };
+    const current: EvalReport = {
+      suite: 'test', timestamp: '', totalCases: 2, passed: 2, failed: 0, passRate: 1, avgLatency: 10, p95Latency: 15, summary: '',
+      results: [
+        { caseId: 'a', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+        { caseId: 'b', input: '', output: '', scores: { latency_ms: 10 }, passed: true },
+      ],
+    };
+    const cmp = AgentEvaluator.compare(baseline, current);
+    expect(cmp.improved).toContain('b');
+    expect(cmp.delta).toBe(0.5);
+  });
+
+  it('should save and load report', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eval-'));
+    const reportPath = path.join(tmpDir, 'report.json');
+    const report: EvalReport = {
+      suite: 'test', timestamp: new Date().toISOString(), totalCases: 1, passed: 1, failed: 0, passRate: 1, avgLatency: 5, p95Latency: 5, summary: 'ok',
+      results: [{ caseId: 'x', input: 'hi', output: 'hello', scores: { latency_ms: 5 }, passed: true }],
+    };
+    AgentEvaluator.saveReport(report, reportPath);
+    const loaded = JSON.parse(fs.readFileSync(reportPath, 'utf-8'));
+    expect(loaded.suite).toBe('test');
+    expect(loaded.results.length).toBe(1);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should run evalSuite and produce report', async () => {
+    const suite: EvalSuite = {
+      name: 'mini',
+      cases: [
+        { id: 't1', input: 'Hello!', expectedContains: ['hello', 'hi'] },
+        { id: 't2', input: 'What is the capital of France?', expectedContains: ['Paris'] },
+      ],
+    };
+    const report = await evaluator.evalSuite(suite);
+    expect(report.totalCases).toBe(2);
+    expect(report.passRate).toBeGreaterThanOrEqual(0);
+    expect(report.summary).toContain('mini');
+  });
+});

package/tests/gateway.test.ts

@@ -1,63 +1,63 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { Gateway } from '../src/core/gateway';
-
-describe('Gateway', () => {
-  let gw: Gateway;
-
-  beforeEach(() => {
-    gw = new Gateway({
-      port: 3000,
-      agents: [{ id: 'agent-1', name: 'Test Agent' }],
-      channels: [{ id: 'ch-1', type: 'web' }],
-    });
-  });
-
-  it('should start and stop', async () => {
-    await gw.start();
-    expect(gw.getStatus().agents).toBe(1);
-    await gw.stop();
-  });
-
-  it('should throw on double start', async () => {
-    await gw.start();
-    await expect(gw.start()).rejects.toThrow('already running');
-    await gw.stop();
-  });
-
-  it('should route messages', async () => {
-    await gw.start();
-    const agentId = await gw.routeMessage({ id: '1', content: 'hi', channel: 'web', timestamp: Date.now() }, 'web');
-    expect(agentId).toBe('agent-1');
-    await gw.stop();
-  });
-
-  it('should add and remove agents', async () => {
-    gw.addAgent({ id: 'agent-2', name: 'Agent 2' });
-    expect(gw.getStatus().agents).toBe(2);
-    gw.removeAgent('agent-2');
-    expect(gw.getStatus().agents).toBe(1);
-  });
-
-  it('should throw removing unknown agent', () => {
-    expect(() => gw.removeAgent('unknown')).toThrow('not found');
-  });
-
-  it('should track status', async () => {
-    await gw.start();
-    const status = gw.getStatus();
-    expect(status.agents).toBe(1);
-    expect(status.channels).toBe(1);
-    expect(status.messagesProcessed).toBe(0);
-    expect(status.uptime).toBeGreaterThanOrEqual(0);
-    await gw.stop();
-  });
-
-  it('should report metrics', async () => {
-    await gw.start();
-    await gw.routeMessage({ id: '1', content: 'test', channel: 'web', timestamp: Date.now() }, 'web');
-    const metrics = gw.getMetrics();
-    expect(metrics.messagesPerMinute).toBeGreaterThan(0);
-    expect(metrics.errorRate).toBe(0);
-    await gw.stop();
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Gateway } from '../src/core/gateway';
+
+describe('Gateway', () => {
+  let gw: Gateway;
+
+  beforeEach(() => {
+    gw = new Gateway({
+      port: 3000,
+      agents: [{ id: 'agent-1', name: 'Test Agent' }],
+      channels: [{ id: 'ch-1', type: 'web' }],
+    });
+  });
+
+  it('should start and stop', async () => {
+    await gw.start();
+    expect(gw.getStatus().agents).toBe(1);
+    await gw.stop();
+  });
+
+  it('should throw on double start', async () => {
+    await gw.start();
+    await expect(gw.start()).rejects.toThrow('already running');
+    await gw.stop();
+  });
+
+  it('should route messages', async () => {
+    await gw.start();
+    const agentId = await gw.routeMessage({ id: '1', content: 'hi', channel: 'web', timestamp: Date.now() }, 'web');
+    expect(agentId).toBe('agent-1');
+    await gw.stop();
+  });
+
+  it('should add and remove agents', async () => {
+    gw.addAgent({ id: 'agent-2', name: 'Agent 2' });
+    expect(gw.getStatus().agents).toBe(2);
+    gw.removeAgent('agent-2');
+    expect(gw.getStatus().agents).toBe(1);
+  });
+
+  it('should throw removing unknown agent', () => {
+    expect(() => gw.removeAgent('unknown')).toThrow('not found');
+  });
+
+  it('should track status', async () => {
+    await gw.start();
+    const status = gw.getStatus();
+    expect(status.agents).toBe(1);
+    expect(status.channels).toBe(1);
+    expect(status.messagesProcessed).toBe(0);
+    expect(status.uptime).toBeGreaterThanOrEqual(0);
+    await gw.stop();
+  });
+
+  it('should report metrics', async () => {
+    await gw.start();
+    await gw.routeMessage({ id: '1', content: 'test', channel: 'web', timestamp: Date.now() }, 'web');
+    const metrics = gw.getMetrics();
+    expect(metrics.messagesPerMinute).toBeGreaterThan(0);
+    expect(metrics.errorRate).toBe(0);
+    await gw.stop();
+  });
+});