opc-agent 1.3.2 → 2.0.0

package/tests/v070.test.ts

@@ -1,76 +1,76 @@
-import { describe, it, expect } from 'vitest';
-import { createAuthMiddleware, getActiveSessions } from '../src/core/auth';
-import { HttpSkill } from '../src/skills/http';
-import { WebhookTriggerSkill } from '../src/skills/webhook-trigger';
-import { SchedulerSkill } from '../src/skills/scheduler';
-import type { AgentContext, Message } from '../src/core/types';
-
-const mockContext: AgentContext = {
-  agentName: 'test',
-  sessionId: 'test-session',
-  messages: [],
-  memory: { get: async () => null, set: async () => {}, getConversation: async () => [], addMessage: async () => {}, clear: async () => {} },
-  metadata: {},
-};
-
-function msg(content: string): Message {
-  return { id: '1', role: 'user', content, timestamp: Date.now() };
-}
-
-describe('Auth', () => {
-  it('should create middleware', () => {
-    const mw = createAuthMiddleware({ apiKeys: ['test-key'] });
-    expect(typeof mw).toBe('function');
-  });
-
-  it('should track sessions', () => {
-    const sessions = getActiveSessions();
-    expect(Array.isArray(sessions)).toBe(true);
-  });
-});
-
-describe('HttpSkill', () => {
-  it('should not match non-http messages', async () => {
-    const skill = new HttpSkill();
-    const result = await skill.execute(mockContext, msg('hello'));
-    expect(result.handled).toBe(false);
-  });
-});
-
-describe('WebhookTriggerSkill', () => {
-  it('should report unknown webhook', async () => {
-    const skill = new WebhookTriggerSkill();
-    const result = await skill.execute(mockContext, msg('webhook test'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('Unknown webhook');
-  });
-
-  it('should register targets', () => {
-    const skill = new WebhookTriggerSkill();
-    skill.registerTarget({ name: 'slack', url: 'https://hooks.slack.com/test' });
-    expect(skill).toBeDefined();
-  });
-});
-
-describe('SchedulerSkill', () => {
-  it('should list empty tasks', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('schedule list'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('No scheduled tasks');
-  });
-
-  it('should add a task', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('schedule add backup "every 5m" run backup'));
-    expect(result.handled).toBe(true);
-    expect(result.response).toContain('Task scheduled');
-    skill.destroy();
-  });
-
-  it('should not match unrelated messages', async () => {
-    const skill = new SchedulerSkill();
-    const result = await skill.execute(mockContext, msg('hello'));
-    expect(result.handled).toBe(false);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { createAuthMiddleware, getActiveSessions } from '../src/core/auth';
+import { HttpSkill } from '../src/skills/http';
+import { WebhookTriggerSkill } from '../src/skills/webhook-trigger';
+import { SchedulerSkill } from '../src/skills/scheduler';
+import type { AgentContext, Message } from '../src/core/types';
+
+const mockContext: AgentContext = {
+  agentName: 'test',
+  sessionId: 'test-session',
+  messages: [],
+  memory: { get: async () => null, set: async () => {}, getConversation: async () => [], addMessage: async () => {}, clear: async () => {} },
+  metadata: {},
+};
+
+function msg(content: string): Message {
+  return { id: '1', role: 'user', content, timestamp: Date.now() };
+}
+
+describe('Auth', () => {
+  it('should create middleware', () => {
+    const mw = createAuthMiddleware({ apiKeys: ['test-key'] });
+    expect(typeof mw).toBe('function');
+  });
+
+  it('should track sessions', () => {
+    const sessions = getActiveSessions();
+    expect(Array.isArray(sessions)).toBe(true);
+  });
+});
+
+describe('HttpSkill', () => {
+  it('should not match non-http messages', async () => {
+    const skill = new HttpSkill();
+    const result = await skill.execute(mockContext, msg('hello'));
+    expect(result.handled).toBe(false);
+  });
+});
+
+describe('WebhookTriggerSkill', () => {
+  it('should report unknown webhook', async () => {
+    const skill = new WebhookTriggerSkill();
+    const result = await skill.execute(mockContext, msg('webhook test'));
+    expect(result.handled).toBe(true);
+    expect(result.response).toContain('Unknown webhook');
+  });
+
+  it('should register targets', () => {
+    const skill = new WebhookTriggerSkill();
+    skill.registerTarget({ name: 'slack', url: 'https://hooks.slack.com/test' });
+    expect(skill).toBeDefined();
+  });
+});
+
+describe('SchedulerSkill', () => {
+  it('should list empty tasks', async () => {
+    const skill = new SchedulerSkill();
+    const result = await skill.execute(mockContext, msg('schedule list'));
+    expect(result.handled).toBe(true);
+    expect(result.response).toContain('No scheduled tasks');
+  });
+
+  it('should add a task', async () => {
+    const skill = new SchedulerSkill();
+    const result = await skill.execute(mockContext, msg('schedule add backup "every 5m" run backup'));
+    expect(result.handled).toBe(true);
+    expect(result.response).toContain('Task scheduled');
+    skill.destroy();
+  });
+
+  it('should not match unrelated messages', async () => {
+    const skill = new SchedulerSkill();
+    const result = await skill.execute(mockContext, msg('hello'));
+    expect(result.handled).toBe(false);
+  });
+});

package/tests/versioning.test.ts

@@ -1,75 +1,75 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { VersionManager } from '../src/core/versioning';
-import * as fs from 'fs';
-
-const TEST_STORE = '.test-versions.json';
-
-describe('VersionManager', () => {
-  let vm: VersionManager;
-
-  beforeEach(() => {
-    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
-    vm = new VersionManager(TEST_STORE);
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
-  });
-
-  it('should save and list versions', () => {
-    vm.snapshot('1.0.0', 'yaml-content-1', 'Initial');
-    vm.snapshot('1.1.0', 'yaml-content-2', 'Update');
-    const versions = vm.list();
-    expect(versions).toHaveLength(2);
-    expect(versions[0].version).toBe('1.0.0');
-  });
-
-  it('should get specific version', () => {
-    vm.snapshot('1.0.0', 'content', 'Test');
-    expect(vm.get('1.0.0')).toBeDefined();
-    expect(vm.get('9.9.9')).toBeUndefined();
-  });
-
-  it('should get current version', () => {
-    vm.snapshot('1.0.0', 'v1');
-    vm.snapshot('2.0.0', 'v2');
-    expect(vm.getCurrent()?.version).toBe('2.0.0');
-  });
-
-  it('should rollback to version', () => {
-    vm.snapshot('1.0.0', 'old-yaml');
-    vm.snapshot('2.0.0', 'new-yaml');
-    const rolled = vm.rollback('1.0.0');
-    expect(rolled).toBe('old-yaml');
-  });
-
-  it('should return null for unknown rollback', () => {
-    expect(vm.rollback('9.9.9')).toBeNull();
-  });
-
-  it('should run migrations', () => {
-    vm.registerMigration({
-      fromVersion: '1.0.0',
-      toVersion: '2.0.0',
-      migrate: (oad) => ({ ...oad, upgraded: true }),
-    });
-    const result = vm.migrate({ data: 'test' }, '1.0.0', '2.0.0');
-    expect((result as any).upgraded).toBe(true);
-  });
-
-  it('should throw on missing migration path', () => {
-    expect(() => vm.migrate({}, '1.0.0', '5.0.0')).toThrow('No migration path');
-  });
-
-  it('should clear all versions', () => {
-    vm.snapshot('1.0.0', 'content');
-    vm.clear();
-    expect(vm.list()).toHaveLength(0);
-  });
-
-  it('should persist to file', () => {
-    vm.snapshot('1.0.0', 'persisted');
-    const vm2 = new VersionManager(TEST_STORE);
-    expect(vm2.list()).toHaveLength(1);
-  });
-});
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { VersionManager } from '../src/core/versioning';
+import * as fs from 'fs';
+
+const TEST_STORE = '.test-versions.json';
+
+describe('VersionManager', () => {
+  let vm: VersionManager;
+
+  beforeEach(() => {
+    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
+    vm = new VersionManager(TEST_STORE);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
+  });
+
+  it('should save and list versions', () => {
+    vm.snapshot('1.0.0', 'yaml-content-1', 'Initial');
+    vm.snapshot('1.1.0', 'yaml-content-2', 'Update');
+    const versions = vm.list();
+    expect(versions).toHaveLength(2);
+    expect(versions[0].version).toBe('1.0.0');
+  });
+
+  it('should get specific version', () => {
+    vm.snapshot('1.0.0', 'content', 'Test');
+    expect(vm.get('1.0.0')).toBeDefined();
+    expect(vm.get('9.9.9')).toBeUndefined();
+  });
+
+  it('should get current version', () => {
+    vm.snapshot('1.0.0', 'v1');
+    vm.snapshot('2.0.0', 'v2');
+    expect(vm.getCurrent()?.version).toBe('2.0.0');
+  });
+
+  it('should rollback to version', () => {
+    vm.snapshot('1.0.0', 'old-yaml');
+    vm.snapshot('2.0.0', 'new-yaml');
+    const rolled = vm.rollback('1.0.0');
+    expect(rolled).toBe('old-yaml');
+  });
+
+  it('should return null for unknown rollback', () => {
+    expect(vm.rollback('9.9.9')).toBeNull();
+  });
+
+  it('should run migrations', () => {
+    vm.registerMigration({
+      fromVersion: '1.0.0',
+      toVersion: '2.0.0',
+      migrate: (oad) => ({ ...oad, upgraded: true }),
+    });
+    const result = vm.migrate({ data: 'test' }, '1.0.0', '2.0.0');
+    expect((result as any).upgraded).toBe(true);
+  });
+
+  it('should throw on missing migration path', () => {
+    expect(() => vm.migrate({}, '1.0.0', '5.0.0')).toThrow('No migration path');
+  });
+
+  it('should clear all versions', () => {
+    vm.snapshot('1.0.0', 'content');
+    vm.clear();
+    expect(vm.list()).toHaveLength(0);
+  });
+
+  it('should persist to file', () => {
+    vm.snapshot('1.0.0', 'persisted');
+    const vm2 = new VersionManager(TEST_STORE);
+    expect(vm2.list()).toHaveLength(1);
+  });
+});

package/tests/voice.test.ts

@@ -1,61 +1,61 @@
-import { describe, it, expect } from 'vitest';
-import { VoiceChannel } from '../src/channels/voice';
-import type { STTProvider, TTSProvider } from '../src/channels/voice';
-
-describe('VoiceChannel', () => {
-  it('should start and stop', async () => {
-    const channel = new VoiceChannel();
-    await channel.start();
-    expect(channel.isRunning()).toBe(true);
-    await channel.stop();
-    expect(channel.isRunning()).toBe(false);
-  });
-
-  it('should process audio with STT/TTS providers', async () => {
-    const stt: STTProvider = {
-      name: 'mock-stt',
-      transcribe: async (audio) => audio.toString('utf-8'),
-    };
-    const tts: TTSProvider = {
-      name: 'mock-tts',
-      synthesize: async (text) => Buffer.from(`audio:${text}`),
-    };
-
-    const channel = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
-    channel.onMessage(async (msg) => ({
-      id: 'r1', role: 'assistant', content: `Reply: ${msg.content}`, timestamp: Date.now(),
-    }));
-    await channel.start();
-
-    const result = await channel.processAudio(Buffer.from('hello'));
-    expect(result.text).toBe('hello');
-    expect(result.response).toBe('Reply: hello');
-    expect(result.audioResponse?.toString()).toBe('audio:Reply: hello');
-  });
-
-  it('should work without providers (text fallback)', async () => {
-    const channel = new VoiceChannel();
-    channel.onMessage(async (msg) => ({
-      id: 'r1', role: 'assistant', content: msg.content, timestamp: Date.now(),
-    }));
-    await channel.start();
-
-    const result = await channel.processAudio(Buffer.from('test'));
-    expect(result.text).toBe('test');
-    expect(result.audioResponse).toBeUndefined();
-  });
-
-  it('should throw without handler', async () => {
-    const channel = new VoiceChannel();
-    await expect(channel.processAudio(Buffer.from('test'))).rejects.toThrow('No message handler');
-  });
-
-  it('should allow setting providers after construction', () => {
-    const channel = new VoiceChannel();
-    const stt: STTProvider = { name: 'stt', transcribe: async () => 'text' };
-    const tts: TTSProvider = { name: 'tts', synthesize: async () => Buffer.from('audio') };
-    channel.setSTTProvider(stt);
-    channel.setTTSProvider(tts);
-    expect(channel.type).toBe('voice');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { VoiceChannel } from '../src/channels/voice';
+import type { STTProvider, TTSProvider } from '../src/channels/voice';
+
+describe('VoiceChannel', () => {
+  it('should start and stop', async () => {
+    const channel = new VoiceChannel();
+    await channel.start();
+    expect(channel.isRunning()).toBe(true);
+    await channel.stop();
+    expect(channel.isRunning()).toBe(false);
+  });
+
+  it('should process audio with STT/TTS providers', async () => {
+    const stt: STTProvider = {
+      name: 'mock-stt',
+      transcribe: async (audio) => audio.toString('utf-8'),
+    };
+    const tts: TTSProvider = {
+      name: 'mock-tts',
+      synthesize: async (text) => Buffer.from(`audio:${text}`),
+    };
+
+    const channel = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
+    channel.onMessage(async (msg) => ({
+      id: 'r1', role: 'assistant', content: `Reply: ${msg.content}`, timestamp: Date.now(),
+    }));
+    await channel.start();
+
+    const result = await channel.processAudio(Buffer.from('hello'));
+    expect(result.text).toBe('hello');
+    expect(result.response).toBe('Reply: hello');
+    expect(result.audioResponse?.toString()).toBe('audio:Reply: hello');
+  });
+
+  it('should work without providers (text fallback)', async () => {
+    const channel = new VoiceChannel();
+    channel.onMessage(async (msg) => ({
+      id: 'r1', role: 'assistant', content: msg.content, timestamp: Date.now(),
+    }));
+    await channel.start();
+
+    const result = await channel.processAudio(Buffer.from('test'));
+    expect(result.text).toBe('test');
+    expect(result.audioResponse).toBeUndefined();
+  });
+
+  it('should throw without handler', async () => {
+    const channel = new VoiceChannel();
+    await expect(channel.processAudio(Buffer.from('test'))).rejects.toThrow('No message handler');
+  });
+
+  it('should allow setting providers after construction', () => {
+    const channel = new VoiceChannel();
+    const stt: STTProvider = { name: 'stt', transcribe: async () => 'text' };
+    const tts: TTSProvider = { name: 'tts', synthesize: async () => Buffer.from('audio') };
+    channel.setSTTProvider(stt);
+    channel.setTTSProvider(tts);
+    expect(channel.type).toBe('voice');
+  });
+});

package/tests/webhook.test.ts

@@ -1,29 +1,29 @@
-import { describe, it, expect } from 'vitest';
-import { WebhookChannel } from '../src/channels/webhook';
-
-describe('WebhookChannel', () => {
-  it('should create with default config', () => {
-    const channel = new WebhookChannel();
-    expect(channel.type).toBe('webhook');
-  });
-
-  it('should verify signatures', () => {
-    const channel = new WebhookChannel({ secret: 'test-secret' });
-    const body = '{"event":"test"}';
-    const sig = channel.createSignature(body, 'test-secret');
-    expect(channel.verifySignature(body, sig, 'test-secret')).toBe(true);
-    expect(channel.verifySignature(body, 'invalid', 'test-secret')).toBe(false);
-  });
-
-  it('should add outgoing webhooks', () => {
-    const channel = new WebhookChannel();
-    channel.addOutgoing({ name: 'test', url: 'http://localhost:9999', events: ['*'], secret: 'abc' });
-    expect(channel.type).toBe('webhook');
-  });
-
-  it('should start and stop server', async () => {
-    const channel = new WebhookChannel({ port: 0 }); // port 0 = random
-    await channel.start();
-    await channel.stop();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { WebhookChannel } from '../src/channels/webhook';
+
+describe('WebhookChannel', () => {
+  it('should create with default config', () => {
+    const channel = new WebhookChannel();
+    expect(channel.type).toBe('webhook');
+  });
+
+  it('should verify signatures', () => {
+    const channel = new WebhookChannel({ secret: 'test-secret' });
+    const body = '{"event":"test"}';
+    const sig = channel.createSignature(body, 'test-secret');
+    expect(channel.verifySignature(body, sig, 'test-secret')).toBe(true);
+    expect(channel.verifySignature(body, 'invalid', 'test-secret')).toBe(false);
+  });
+
+  it('should add outgoing webhooks', () => {
+    const channel = new WebhookChannel();
+    channel.addOutgoing({ name: 'test', url: 'http://localhost:9999', events: ['*'], secret: 'abc' });
+    expect(channel.type).toBe('webhook');
+  });
+
+  it('should start and stop server', async () => {
+    const channel = new WebhookChannel({ port: 0 }); // port 0 = random
+    await channel.start();
+    await channel.stop();
+  });
+});