opc-agent 1.2.0 → 1.2.1

package/tests/plugin.test.ts

@@ -1,74 +1,74 @@
-import { describe, it, expect } from 'vitest';
-import { PluginManager } from '../src/plugins';
-import type { IPlugin } from '../src/plugins';
-
-describe('Plugin System', () => {
-  it('should register and list plugins', () => {
-    const pm = new PluginManager();
-    const plugin: IPlugin = { name: 'test-plugin', version: '1.0.0', description: 'Test' };
-    pm.register(plugin);
-    expect(pm.has('test-plugin')).toBe(true);
-    expect(pm.list().length).toBe(1);
-    expect(pm.list()[0].name).toBe('test-plugin');
-  });
-
-  it('should run lifecycle hooks', async () => {
-    const pm = new PluginManager();
-    const calls: string[] = [];
-
-    pm.register({
-      name: 'hook-plugin',
-      version: '1.0.0',
-      hooks: {
-        beforeInit: async () => { calls.push('beforeInit'); },
-        afterInit: async () => { calls.push('afterInit'); },
-        beforeShutdown: async () => { calls.push('beforeShutdown'); },
-      },
-    });
-
-    await pm.runHook('beforeInit');
-    await pm.runHook('afterInit');
-    await pm.runHook('beforeShutdown');
-    expect(calls).toEqual(['beforeInit', 'afterInit', 'beforeShutdown']);
-  });
-
-  it('should collect skills from plugins', () => {
-    const pm = new PluginManager();
-    pm.register({
-      name: 'skill-plugin',
-      version: '1.0.0',
-      skills: [{
-        name: 'test-skill',
-        description: 'Test',
-        execute: async () => ({ handled: false, confidence: 0 }),
-      }],
-    });
-
-    expect(pm.getAllSkills().length).toBe(1);
-    expect(pm.getAllSkills()[0].name).toBe('test-skill');
-  });
-
-  it('should unregister plugins', () => {
-    const pm = new PluginManager();
-    pm.register({ name: 'temp', version: '1.0.0' });
-    pm.unregister('temp');
-    expect(pm.has('temp')).toBe(false);
-  });
-
-  it('should run hooks from multiple plugins in order', async () => {
-    const pm = new PluginManager();
-    const order: string[] = [];
-
-    pm.register({
-      name: 'p1', version: '1.0.0',
-      hooks: { beforeInit: async () => { order.push('p1'); } },
-    });
-    pm.register({
-      name: 'p2', version: '1.0.0',
-      hooks: { beforeInit: async () => { order.push('p2'); } },
-    });
-
-    await pm.runHook('beforeInit');
-    expect(order).toEqual(['p1', 'p2']);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { PluginManager } from '../src/plugins';
+import type { IPlugin } from '../src/plugins';
+
+describe('Plugin System', () => {
+  it('should register and list plugins', () => {
+    const pm = new PluginManager();
+    const plugin: IPlugin = { name: 'test-plugin', version: '1.0.0', description: 'Test' };
+    pm.register(plugin);
+    expect(pm.has('test-plugin')).toBe(true);
+    expect(pm.list().length).toBe(1);
+    expect(pm.list()[0].name).toBe('test-plugin');
+  });
+
+  it('should run lifecycle hooks', async () => {
+    const pm = new PluginManager();
+    const calls: string[] = [];
+
+    pm.register({
+      name: 'hook-plugin',
+      version: '1.0.0',
+      hooks: {
+        beforeInit: async () => { calls.push('beforeInit'); },
+        afterInit: async () => { calls.push('afterInit'); },
+        beforeShutdown: async () => { calls.push('beforeShutdown'); },
+      },
+    });
+
+    await pm.runHook('beforeInit');
+    await pm.runHook('afterInit');
+    await pm.runHook('beforeShutdown');
+    expect(calls).toEqual(['beforeInit', 'afterInit', 'beforeShutdown']);
+  });
+
+  it('should collect skills from plugins', () => {
+    const pm = new PluginManager();
+    pm.register({
+      name: 'skill-plugin',
+      version: '1.0.0',
+      skills: [{
+        name: 'test-skill',
+        description: 'Test',
+        execute: async () => ({ handled: false, confidence: 0 }),
+      }],
+    });
+
+    expect(pm.getAllSkills().length).toBe(1);
+    expect(pm.getAllSkills()[0].name).toBe('test-skill');
+  });
+
+  it('should unregister plugins', () => {
+    const pm = new PluginManager();
+    pm.register({ name: 'temp', version: '1.0.0' });
+    pm.unregister('temp');
+    expect(pm.has('temp')).toBe(false);
+  });
+
+  it('should run hooks from multiple plugins in order', async () => {
+    const pm = new PluginManager();
+    const order: string[] = [];
+
+    pm.register({
+      name: 'p1', version: '1.0.0',
+      hooks: { beforeInit: async () => { order.push('p1'); } },
+    });
+    pm.register({
+      name: 'p2', version: '1.0.0',
+      hooks: { beforeInit: async () => { order.push('p2'); } },
+    });
+
+    await pm.runHook('beforeInit');
+    expect(order).toEqual(['p1', 'p2']);
+  });
+});

package/tests/room.test.ts

@@ -1,106 +1,106 @@
-import { describe, it, expect } from 'vitest';
-import { Room } from '../src/core/room';
-import { BaseAgent } from '../src/core/agent';
-
-function makeAgent(name: string): BaseAgent {
-  const agent = new BaseAgent({ name });
-  // Synchronously set to ready by calling init
-  return agent;
-}
-
-describe('Room System', () => {
-  it('should create a room with a name', () => {
-    const room = new Room('test-room');
-    expect(room.name).toBe('test-room');
-    expect(room.getAgents()).toEqual([]);
-  });
-
-  it('should add and remove agents', () => {
-    const room = new Room('office');
-    const agent = makeAgent('agent-1');
-    room.addAgent(agent);
-    expect(room.getAgents()).toEqual(['agent-1']);
-    room.removeAgent('agent-1');
-    expect(room.getAgents()).toEqual([]);
-  });
-
-  it('should emit events on join/leave', () => {
-    const room = new Room('office');
-    const events: string[] = [];
-    room.on('agent:join', (name) => events.push(`join:${name}`));
-    room.on('agent:leave', (name) => events.push(`leave:${name}`));
-
-    const agent = makeAgent('a1');
-    room.addAgent(agent);
-    room.removeAgent('a1');
-    expect(events).toEqual(['join:a1', 'leave:a1']);
-  });
-
-  it('should support topic subscriptions', () => {
-    const room = new Room('office');
-    room.subscribe('agent-1', 'alerts');
-    room.subscribe('agent-2', 'alerts');
-    expect(room.getSubscribers('alerts')).toEqual(['agent-1', 'agent-2']);
-    room.unsubscribe('agent-1', 'alerts');
-    expect(room.getSubscribers('alerts')).toEqual(['agent-2']);
-  });
-
-  it('should broadcast to all agents except sender', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    await a1.init();
-    await a2.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-
-    const responses = await room.broadcast('a1', 'Hello everyone');
-    expect(responses.length).toBe(1); // only a2 responds
-    expect(responses[0].role).toBe('assistant');
-  });
-
-  it('should send direct messages', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    await a1.init();
-    await a2.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-
-    const responses = await room.send({
-      from: 'a1',
-      to: 'a2',
-      message: { id: 'm1', role: 'user', content: 'Hi a2', timestamp: Date.now() },
-    });
-    expect(responses.length).toBe(1);
-  });
-
-  it('should publish to topic subscribers only', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    const a3 = makeAgent('a3');
-    await a1.init();
-    await a2.init();
-    await a3.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-    room.addAgent(a3);
-
-    room.subscribe('a2', 'alerts');
-    // a3 not subscribed
-    const responses = await room.publishToTopic('a1', 'alerts', 'Alert!');
-    expect(responses.length).toBe(1);
-  });
-
-  it('should remove agent from subscriptions on leave', () => {
-    const room = new Room('office');
-    room.subscribe('a1', 'topic1');
-    room.subscribe('a1', 'topic2');
-    expect(room.getSubscribers('topic1')).toContain('a1');
-    room.removeAgent('a1');
-    expect(room.getSubscribers('topic1')).not.toContain('a1');
-    expect(room.getSubscribers('topic2')).not.toContain('a1');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { Room } from '../src/core/room';
+import { BaseAgent } from '../src/core/agent';
+
+function makeAgent(name: string): BaseAgent {
+  const agent = new BaseAgent({ name });
+  // Synchronously set to ready by calling init
+  return agent;
+}
+
+describe('Room System', () => {
+  it('should create a room with a name', () => {
+    const room = new Room('test-room');
+    expect(room.name).toBe('test-room');
+    expect(room.getAgents()).toEqual([]);
+  });
+
+  it('should add and remove agents', () => {
+    const room = new Room('office');
+    const agent = makeAgent('agent-1');
+    room.addAgent(agent);
+    expect(room.getAgents()).toEqual(['agent-1']);
+    room.removeAgent('agent-1');
+    expect(room.getAgents()).toEqual([]);
+  });
+
+  it('should emit events on join/leave', () => {
+    const room = new Room('office');
+    const events: string[] = [];
+    room.on('agent:join', (name) => events.push(`join:${name}`));
+    room.on('agent:leave', (name) => events.push(`leave:${name}`));
+
+    const agent = makeAgent('a1');
+    room.addAgent(agent);
+    room.removeAgent('a1');
+    expect(events).toEqual(['join:a1', 'leave:a1']);
+  });
+
+  it('should support topic subscriptions', () => {
+    const room = new Room('office');
+    room.subscribe('agent-1', 'alerts');
+    room.subscribe('agent-2', 'alerts');
+    expect(room.getSubscribers('alerts')).toEqual(['agent-1', 'agent-2']);
+    room.unsubscribe('agent-1', 'alerts');
+    expect(room.getSubscribers('alerts')).toEqual(['agent-2']);
+  });
+
+  it('should broadcast to all agents except sender', async () => {
+    const room = new Room('office');
+    const a1 = makeAgent('a1');
+    const a2 = makeAgent('a2');
+    await a1.init();
+    await a2.init();
+    room.addAgent(a1);
+    room.addAgent(a2);
+
+    const responses = await room.broadcast('a1', 'Hello everyone');
+    expect(responses.length).toBe(1); // only a2 responds
+    expect(responses[0].role).toBe('assistant');
+  });
+
+  it('should send direct messages', async () => {
+    const room = new Room('office');
+    const a1 = makeAgent('a1');
+    const a2 = makeAgent('a2');
+    await a1.init();
+    await a2.init();
+    room.addAgent(a1);
+    room.addAgent(a2);
+
+    const responses = await room.send({
+      from: 'a1',
+      to: 'a2',
+      message: { id: 'm1', role: 'user', content: 'Hi a2', timestamp: Date.now() },
+    });
+    expect(responses.length).toBe(1);
+  });
+
+  it('should publish to topic subscribers only', async () => {
+    const room = new Room('office');
+    const a1 = makeAgent('a1');
+    const a2 = makeAgent('a2');
+    const a3 = makeAgent('a3');
+    await a1.init();
+    await a2.init();
+    await a3.init();
+    room.addAgent(a1);
+    room.addAgent(a2);
+    room.addAgent(a3);
+
+    room.subscribe('a2', 'alerts');
+    // a3 not subscribed
+    const responses = await room.publishToTopic('a1', 'alerts', 'Alert!');
+    expect(responses.length).toBe(1);
+  });
+
+  it('should remove agent from subscriptions on leave', () => {
+    const room = new Room('office');
+    room.subscribe('a1', 'topic1');
+    room.subscribe('a1', 'topic2');
+    expect(room.getSubscribers('topic1')).toContain('a1');
+    room.removeAgent('a1');
+    expect(room.getSubscribers('topic1')).not.toContain('a1');
+    expect(room.getSubscribers('topic2')).not.toContain('a1');
+  });
+});

package/tests/runtime.test.ts

@@ -1,42 +1,42 @@
-import { describe, it, expect } from 'vitest';
-import { AgentRuntime } from '../src/core/runtime';
-import { createCustomerServiceConfig } from '../src/templates/customer-service';
-
-describe('AgentRuntime', () => {
-  it('should initialize from config object', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    const agent = await runtime.initialize(config);
-    expect(agent.name).toBe('customer-service');
-    expect(agent.state).toBe('ready');
-  });
-
-  it('should throw if no config loaded', async () => {
-    const runtime = new AgentRuntime();
-    await expect(runtime.initialize()).rejects.toThrow('No config loaded');
-  });
-
-  it('should register skills after initialization', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    await runtime.initialize(config);
-
-    runtime.registerSkill({
-      name: 'test-skill',
-      description: 'Test',
-      execute: async () => ({ handled: false, confidence: 0 }),
-    });
-    // No throw = success
-  });
-
-  it('should throw registering skill before init', () => {
-    const runtime = new AgentRuntime();
-    expect(() =>
-      runtime.registerSkill({
-        name: 'test',
-        description: 'Test',
-        execute: async () => ({ handled: false, confidence: 0 }),
-      })
-    ).toThrow('Agent not initialized');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { AgentRuntime } from '../src/core/runtime';
+import { createCustomerServiceConfig } from '../src/templates/customer-service';
+
+describe('AgentRuntime', () => {
+  it('should initialize from config object', async () => {
+    const runtime = new AgentRuntime();
+    const config = createCustomerServiceConfig();
+    const agent = await runtime.initialize(config);
+    expect(agent.name).toBe('customer-service');
+    expect(agent.state).toBe('ready');
+  });
+
+  it('should throw if no config loaded', async () => {
+    const runtime = new AgentRuntime();
+    await expect(runtime.initialize()).rejects.toThrow('No config loaded');
+  });
+
+  it('should register skills after initialization', async () => {
+    const runtime = new AgentRuntime();
+    const config = createCustomerServiceConfig();
+    await runtime.initialize(config);
+
+    runtime.registerSkill({
+      name: 'test-skill',
+      description: 'Test',
+      execute: async () => ({ handled: false, confidence: 0 }),
+    });
+    // No throw = success
+  });
+
+  it('should throw registering skill before init', () => {
+    const runtime = new AgentRuntime();
+    expect(() =>
+      runtime.registerSkill({
+        name: 'test',
+        description: 'Test',
+        execute: async () => ({ handled: false, confidence: 0 }),
+      })
+    ).toThrow('Agent not initialized');
+  });
+});

package/tests/sandbox.test.ts

@@ -1,46 +1,46 @@
-import { describe, it, expect } from 'vitest';
-import { Sandbox } from '../src/core/sandbox';
-
-describe('Security Sandbox', () => {
-  it('should create sandbox with trust level', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.trustLevel).toBe('sandbox');
-  });
-
-  it('should restrict shell in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(false);
-  });
-
-  it('should allow shell in certified mode', () => {
-    const sb = new Sandbox({ trustLevel: 'certified', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(true);
-  });
-
-  it('should restrict network in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://api.openai.com')).toBe(false);
-  });
-
-  it('should allow network with allowlist', () => {
-    const sb = new Sandbox({
-      trustLevel: 'sandbox',
-      agentDir: '/tmp/agent',
-      networkAllowlist: ['api.openai.com'],
-    });
-    expect(sb.checkNetworkAccess('https://api.openai.com/v1/chat')).toBe(true);
-    expect(sb.checkNetworkAccess('https://evil.com')).toBe(false);
-  });
-
-  it('should allow wildcard network in listed mode', () => {
-    const sb = new Sandbox({ trustLevel: 'listed', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://anything.com')).toBe(true);
-  });
-
-  it('should return restrictions snapshot', () => {
-    const sb = new Sandbox({ trustLevel: 'verified', agentDir: '/tmp/agent' });
-    const r = sb.getRestrictions();
-    expect(r.shell).toBe(false);
-    expect(r.network.allowed.length).toBeGreaterThan(0);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { Sandbox } from '../src/core/sandbox';
+
+describe('Security Sandbox', () => {
+  it('should create sandbox with trust level', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.trustLevel).toBe('sandbox');
+  });
+
+  it('should restrict shell in sandbox mode', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.checkShellAccess()).toBe(false);
+  });
+
+  it('should allow shell in certified mode', () => {
+    const sb = new Sandbox({ trustLevel: 'certified', agentDir: '/tmp/agent' });
+    expect(sb.checkShellAccess()).toBe(true);
+  });
+
+  it('should restrict network in sandbox mode', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.checkNetworkAccess('https://api.openai.com')).toBe(false);
+  });
+
+  it('should allow network with allowlist', () => {
+    const sb = new Sandbox({
+      trustLevel: 'sandbox',
+      agentDir: '/tmp/agent',
+      networkAllowlist: ['api.openai.com'],
+    });
+    expect(sb.checkNetworkAccess('https://api.openai.com/v1/chat')).toBe(true);
+    expect(sb.checkNetworkAccess('https://evil.com')).toBe(false);
+  });
+
+  it('should allow wildcard network in listed mode', () => {
+    const sb = new Sandbox({ trustLevel: 'listed', agentDir: '/tmp/agent' });
+    expect(sb.checkNetworkAccess('https://anything.com')).toBe(true);
+  });
+
+  it('should return restrictions snapshot', () => {
+    const sb = new Sandbox({ trustLevel: 'verified', agentDir: '/tmp/agent' });
+    const r = sb.getRestrictions();
+    expect(r.shell).toBe(false);
+    expect(r.network.allowed.length).toBeGreaterThan(0);
+  });
+});

package/tests/security.test.ts

@@ -1,60 +1,60 @@
-import { describe, it, expect } from 'vitest';
-import { sanitizeInput, detectInjection, APIKeyManager } from '../src/core/security';
-
-describe('Security', () => {
-  describe('sanitizeInput', () => {
-    it('strips script tags', () => {
-      expect(sanitizeInput('<script>alert(1)</script>hello')).not.toContain('<script');
-    });
-    it('encodes HTML entities', () => {
-      const result = sanitizeInput('a < b & c > d');
-      expect(result).toContain('&lt;');
-      expect(result).toContain('&amp;');
-      expect(result).toContain('&gt;');
-    });
-  });
-
-  describe('detectInjection', () => {
-    it('detects XSS', () => {
-      const r = detectInjection('<script>alert(1)</script>');
-      expect(r.safe).toBe(false);
-      expect(r.threats).toContain('xss');
-    });
-    it('passes clean input', () => {
-      expect(detectInjection('Hello world')).toEqual({ safe: true, threats: [] });
-    });
-  });
-
-  describe('APIKeyManager', () => {
-    it('add, validate, revoke', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('key1', { label: 'test' });
-      expect(mgr.isValid('key1')).toBe(true);
-      expect(mgr.isValid('key2')).toBe(false);
-      mgr.revokeKey('key1');
-      expect(mgr.isValid('key1')).toBe(false);
-    });
-
-    it('rotate key', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('old');
-      expect(mgr.rotateKey('old', 'new')).toBe(true);
-      expect(mgr.isValid('old')).toBe(false);
-      expect(mgr.isValid('new')).toBe(true);
-    });
-
-    it('expires keys', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('expired', { expiresAt: Date.now() - 1000 });
-      expect(mgr.isValid('expired')).toBe(false);
-    });
-
-    it('listActive filters', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('a');
-      mgr.addKey('b');
-      mgr.revokeKey('b');
-      expect(mgr.listActive().length).toBe(1);
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { sanitizeInput, detectInjection, APIKeyManager } from '../src/core/security';
+
+describe('Security', () => {
+  describe('sanitizeInput', () => {
+    it('strips script tags', () => {
+      expect(sanitizeInput('<script>alert(1)</script>hello')).not.toContain('<script');
+    });
+    it('encodes HTML entities', () => {
+      const result = sanitizeInput('a < b & c > d');
+      expect(result).toContain('&lt;');
+      expect(result).toContain('&amp;');
+      expect(result).toContain('&gt;');
+    });
+  });
+
+  describe('detectInjection', () => {
+    it('detects XSS', () => {
+      const r = detectInjection('<script>alert(1)</script>');
+      expect(r.safe).toBe(false);
+      expect(r.threats).toContain('xss');
+    });
+    it('passes clean input', () => {
+      expect(detectInjection('Hello world')).toEqual({ safe: true, threats: [] });
+    });
+  });
+
+  describe('APIKeyManager', () => {
+    it('add, validate, revoke', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('key1', { label: 'test' });
+      expect(mgr.isValid('key1')).toBe(true);
+      expect(mgr.isValid('key2')).toBe(false);
+      mgr.revokeKey('key1');
+      expect(mgr.isValid('key1')).toBe(false);
+    });
+
+    it('rotate key', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('old');
+      expect(mgr.rotateKey('old', 'new')).toBe(true);
+      expect(mgr.isValid('old')).toBe(false);
+      expect(mgr.isValid('new')).toBe(true);
+    });
+
+    it('expires keys', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('expired', { expiresAt: Date.now() - 1000 });
+      expect(mgr.isValid('expired')).toBe(false);
+    });
+
+    it('listActive filters', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('a');
+      mgr.addKey('b');
+      mgr.revokeKey('b');
+      expect(mgr.listActive().length).toBe(1);
+    });
+  });
+});