opc-agent 1.1.1 → 1.1.2

package/tests/channel.test.ts

@@ -1,39 +1,39 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { WebChannel } from '../src/channels/web';
-
-describe('WebChannel', () => {
-  let channel: WebChannel | null = null;
-
-  afterEach(async () => {
-    if (channel) {
-      await channel.stop();
-      channel = null;
-    }
-  });
-
-  it('should create with default port', () => {
-    channel = new WebChannel();
-    expect(channel.type).toBe('web');
-  });
-
-  it('should start and stop', async () => {
-    channel = new WebChannel(0); // random port
-    channel.onMessage(async (msg) => ({
-      id: 'resp_1',
-      role: 'assistant',
-      content: `Echo: ${msg.content}`,
-      timestamp: Date.now(),
-    }));
-    await channel.start();
-    await channel.stop();
-    channel = null;
-  });
-
-  it('should handle health check', async () => {
-    channel = new WebChannel(0);
-    await channel.start();
-    // Channel is running — health endpoint is available
-    await channel.stop();
-    channel = null;
-  });
-});
+import { describe, it, expect, afterEach } from 'vitest';
+import { WebChannel } from '../src/channels/web';
+
+describe('WebChannel', () => {
+  let channel: WebChannel | null = null;
+
+  afterEach(async () => {
+    if (channel) {
+      await channel.stop();
+      channel = null;
+    }
+  });
+
+  it('should create with default port', () => {
+    channel = new WebChannel();
+    expect(channel.type).toBe('web');
+  });
+
+  it('should start and stop', async () => {
+    channel = new WebChannel(0); // random port
+    channel.onMessage(async (msg) => ({
+      id: 'resp_1',
+      role: 'assistant',
+      content: `Echo: ${msg.content}`,
+      timestamp: Date.now(),
+    }));
+    await channel.start();
+    await channel.stop();
+    channel = null;
+  });
+
+  it('should handle health check', async () => {
+    channel = new WebChannel(0);
+    await channel.start();
+    // Channel is running — health endpoint is available
+    await channel.stop();
+    channel = null;
+  });
+});

package/tests/e2e.test.ts

@@ -1,134 +1,134 @@
-import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
-import { AgentRuntime } from '../src/core/runtime';
-import { createCustomerServiceConfig } from '../src/templates/customer-service';
-import * as http from 'http';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-
-function httpPost(url: string, body: any): Promise<{ status: number; body: string }> {
-  return new Promise((resolve, reject) => {
-    const u = new URL(url);
-    const postData = JSON.stringify(body);
-    const req = http.request(
-      {
-        hostname: u.hostname,
-        port: u.port,
-        path: u.pathname,
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) },
-      },
-      (res) => {
-        let data = '';
-        res.on('data', (chunk: Buffer) => (data += chunk.toString()));
-        res.on('end', () => resolve({ status: res.statusCode ?? 0, body: data }));
-      },
-    );
-    req.on('error', reject);
-    req.write(postData);
-    req.end();
-  });
-}
-
-function httpGet(url: string): Promise<{ status: number; body: string }> {
-  return new Promise((resolve, reject) => {
-    const u = new URL(url);
-    http.get({ hostname: u.hostname, port: u.port, path: u.pathname }, (res) => {
-      let data = '';
-      res.on('data', (chunk: Buffer) => (data += chunk.toString()));
-      res.on('end', () => resolve({ status: res.statusCode ?? 0, body: data }));
-    }).on('error', reject);
-  });
-}
-
-describe('OPC Agent E2E', () => {
-  let runtime: AgentRuntime;
-  const port = 3456;
-
-  beforeAll(async () => {
-    // Mock LLM by setting env to use a fake provider
-    // We'll test the web channel serves and responds
-    const config = createCustomerServiceConfig();
-    config.metadata.name = 'test-agent';
-    config.spec.channels = [{ type: 'web' as const, port }];
-
-    runtime = new AgentRuntime();
-    // Write temp oad.yaml
-    const tmpDir = path.join(__dirname, '..', 'tmp-test');
-    fs.mkdirSync(tmpDir, { recursive: true });
-    const oadPath = path.join(tmpDir, 'oad.yaml');
-    fs.writeFileSync(oadPath, yaml.dump(config));
-
-    await runtime.loadConfig(oadPath);
-    await runtime.initialize();
-    await runtime.start();
-
-    // Clean up temp
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }, 15000);
-
-  afterAll(async () => {
-    await runtime.stop();
-  });
-
-  it('serves chat UI at /', async () => {
-    const res = await httpGet(`http://localhost:${port}/`);
-    expect(res.status).toBe(200);
-    expect(res.body).toContain('OPC Agent');
-    expect(res.body).toContain('<html');
-  });
-
-  it('health endpoint returns ok', async () => {
-    const res = await httpGet(`http://localhost:${port}/health`);
-    expect(res.status).toBe(200);
-    const data = JSON.parse(res.body);
-    expect(data.status).toBe('ok');
-  });
-
-  it('POST /api/chat returns SSE stream', async () => {
-    const res = await httpPost(`http://localhost:${port}/api/chat`, {
-      message: 'Hello',
-      sessionId: 'test-1',
-    });
-    // Should get 200 (streaming response or error about API key)
-    expect(res.status).toBe(200);
-    // Response should contain SSE data lines
-    expect(res.body).toContain('data: ');
-  });
-
-  it('rejects empty message', async () => {
-    const res = await httpPost(`http://localhost:${port}/api/chat`, {});
-    expect(res.status).toBe(400);
-  });
-
-  it('GET /api/info returns agent name', async () => {
-    const res = await httpGet(`http://localhost:${port}/api/info`);
-    expect(res.status).toBe(200);
-    const data = JSON.parse(res.body);
-    expect(data.name).toBe('test-agent');
-  });
-});
-
-describe('Init template', () => {
-  const testDir = path.join(__dirname, '..', 'tmp-init-test');
-
-  afterAll(() => {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
-
-  it('creates all expected files', () => {
-    // Simulate init
-    fs.mkdirSync(testDir, { recursive: true });
-    const config = createCustomerServiceConfig();
-    config.metadata.name = 'test-init';
-    fs.writeFileSync(path.join(testDir, 'oad.yaml'), yaml.dump(config));
-    fs.writeFileSync(path.join(testDir, '.env.example'), 'OPC_LLM_API_KEY=test\n');
-    fs.writeFileSync(path.join(testDir, 'package.json'), '{}');
-    fs.writeFileSync(path.join(testDir, 'README.md'), '# test');
-
-    expect(fs.existsSync(path.join(testDir, 'oad.yaml'))).toBe(true);
-    expect(fs.existsSync(path.join(testDir, '.env.example'))).toBe(true);
-    expect(fs.existsSync(path.join(testDir, 'package.json'))).toBe(true);
-    expect(fs.existsSync(path.join(testDir, 'README.md'))).toBe(true);
-  });
-});
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { AgentRuntime } from '../src/core/runtime';
+import { createCustomerServiceConfig } from '../src/templates/customer-service';
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+function httpPost(url: string, body: any): Promise<{ status: number; body: string }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const postData = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: u.hostname,
+        port: u.port,
+        path: u.pathname,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) },
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk: Buffer) => (data += chunk.toString()));
+        res.on('end', () => resolve({ status: res.statusCode ?? 0, body: data }));
+      },
+    );
+    req.on('error', reject);
+    req.write(postData);
+    req.end();
+  });
+}
+
+function httpGet(url: string): Promise<{ status: number; body: string }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    http.get({ hostname: u.hostname, port: u.port, path: u.pathname }, (res) => {
+      let data = '';
+      res.on('data', (chunk: Buffer) => (data += chunk.toString()));
+      res.on('end', () => resolve({ status: res.statusCode ?? 0, body: data }));
+    }).on('error', reject);
+  });
+}
+
+describe('OPC Agent E2E', () => {
+  let runtime: AgentRuntime;
+  const port = 3456;
+
+  beforeAll(async () => {
+    // Mock LLM by setting env to use a fake provider
+    // We'll test the web channel serves and responds
+    const config = createCustomerServiceConfig();
+    config.metadata.name = 'test-agent';
+    config.spec.channels = [{ type: 'web' as const, port }];
+
+    runtime = new AgentRuntime();
+    // Write temp oad.yaml
+    const tmpDir = path.join(__dirname, '..', 'tmp-test');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const oadPath = path.join(tmpDir, 'oad.yaml');
+    fs.writeFileSync(oadPath, yaml.dump(config));
+
+    await runtime.loadConfig(oadPath);
+    await runtime.initialize();
+    await runtime.start();
+
+    // Clean up temp
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }, 15000);
+
+  afterAll(async () => {
+    await runtime.stop();
+  });
+
+  it('serves chat UI at /', async () => {
+    const res = await httpGet(`http://localhost:${port}/`);
+    expect(res.status).toBe(200);
+    expect(res.body).toContain('OPC Agent');
+    expect(res.body).toContain('<html');
+  });
+
+  it('health endpoint returns ok', async () => {
+    const res = await httpGet(`http://localhost:${port}/health`);
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data.status).toBe('ok');
+  });
+
+  it('POST /api/chat returns SSE stream', async () => {
+    const res = await httpPost(`http://localhost:${port}/api/chat`, {
+      message: 'Hello',
+      sessionId: 'test-1',
+    });
+    // Should get 200 (streaming response or error about API key)
+    expect(res.status).toBe(200);
+    // Response should contain SSE data lines
+    expect(res.body).toContain('data: ');
+  });
+
+  it('rejects empty message', async () => {
+    const res = await httpPost(`http://localhost:${port}/api/chat`, {});
+    expect(res.status).toBe(400);
+  });
+
+  it('GET /api/info returns agent name', async () => {
+    const res = await httpGet(`http://localhost:${port}/api/info`);
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data.name).toBe('test-agent');
+  });
+});
+
+describe('Init template', () => {
+  const testDir = path.join(__dirname, '..', 'tmp-init-test');
+
+  afterAll(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('creates all expected files', () => {
+    // Simulate init
+    fs.mkdirSync(testDir, { recursive: true });
+    const config = createCustomerServiceConfig();
+    config.metadata.name = 'test-init';
+    fs.writeFileSync(path.join(testDir, 'oad.yaml'), yaml.dump(config));
+    fs.writeFileSync(path.join(testDir, '.env.example'), 'OPC_LLM_API_KEY=test\n');
+    fs.writeFileSync(path.join(testDir, 'package.json'), '{}');
+    fs.writeFileSync(path.join(testDir, 'README.md'), '# test');
+
+    expect(fs.existsSync(path.join(testDir, 'oad.yaml'))).toBe(true);
+    expect(fs.existsSync(path.join(testDir, '.env.example'))).toBe(true);
+    expect(fs.existsSync(path.join(testDir, 'package.json'))).toBe(true);
+    expect(fs.existsSync(path.join(testDir, 'README.md'))).toBe(true);
+  });
+});

package/tests/errors.test.ts

@@ -1,83 +1,83 @@
-import { describe, it, expect } from 'vitest';
-import { OPCError, ProviderError, ValidationError, ConfigError, ChannelError, PluginError, RateLimitError, SecurityError, TimeoutError, wrapError, formatErrorForUser } from '../src/core/errors';
-
-describe('Error Hierarchy', () => {
-  it('OPCError has code, hint, timestamp', () => {
-    const err = new OPCError('boom', { code: 'TEST', hint: 'try again' });
-    expect(err.message).toBe('boom');
-    expect(err.code).toBe('TEST');
-    expect(err.hint).toBe('try again');
-    expect(err.timestamp).toBeGreaterThan(0);
-    expect(err.toUserMessage()).toContain('try again');
-  });
-
-  it('toJSON serializes correctly', () => {
-    const err = new OPCError('test', { code: 'T1' });
-    const json = err.toJSON();
-    expect(json.name).toBe('OPCError');
-    expect(json.code).toBe('T1');
-  });
-
-  it('ProviderError includes provider', () => {
-    const err = new ProviderError('openai', 'API key invalid', { statusCode: 401 });
-    expect(err.provider).toBe('openai');
-    expect(err.statusCode).toBe(401);
-    expect(err.code).toBe('OPC_PROVIDER_ERROR');
-    expect(err instanceof OPCError).toBe(true);
-  });
-
-  it('ValidationError includes errors array', () => {
-    const err = new ValidationError('Invalid config', ['missing name', 'bad version'], 'metadata');
-    expect(err.errors).toEqual(['missing name', 'bad version']);
-    expect(err.field).toBe('metadata');
-  });
-
-  it('ConfigError', () => {
-    const err = new ConfigError('Missing oad.yaml');
-    expect(err.code).toBe('OPC_CONFIG_ERROR');
-  });
-
-  it('ChannelError', () => {
-    const err = new ChannelError('web', 'Port in use');
-    expect(err.channelType).toBe('web');
-  });
-
-  it('PluginError', () => {
-    const err = new PluginError('my-plugin', 'Init failed');
-    expect(err.pluginName).toBe('my-plugin');
-  });
-
-  it('RateLimitError', () => {
-    const err = new RateLimitError(undefined, 5000);
-    expect(err.retryAfterMs).toBe(5000);
-    expect(err.toUserMessage()).toContain('5 seconds');
-  });
-
-  it('SecurityError', () => {
-    const err = new SecurityError('Blocked');
-    expect(err.code).toBe('OPC_SECURITY_ERROR');
-  });
-
-  it('TimeoutError', () => {
-    const err = new TimeoutError('llm-call', 30000);
-    expect(err.message).toContain('30000ms');
-  });
-
-  it('wrapError wraps unknown errors', () => {
-    const wrapped = wrapError('string error');
-    expect(wrapped instanceof OPCError).toBe(true);
-    expect(wrapped.message).toBe('string error');
-
-    const native = wrapError(new Error('native'));
-    expect(native.message).toBe('native');
-
-    const existing = new ProviderError('x', 'y');
-    expect(wrapError(existing)).toBe(existing);
-  });
-
-  it('formatErrorForUser returns clean message', () => {
-    expect(formatErrorForUser(new RateLimitError())).toContain('Rate limit');
-    expect(formatErrorForUser(new Error('raw'))).toBe('raw');
-    expect(formatErrorForUser('string')).toBe('string');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { OPCError, ProviderError, ValidationError, ConfigError, ChannelError, PluginError, RateLimitError, SecurityError, TimeoutError, wrapError, formatErrorForUser } from '../src/core/errors';
+
+describe('Error Hierarchy', () => {
+  it('OPCError has code, hint, timestamp', () => {
+    const err = new OPCError('boom', { code: 'TEST', hint: 'try again' });
+    expect(err.message).toBe('boom');
+    expect(err.code).toBe('TEST');
+    expect(err.hint).toBe('try again');
+    expect(err.timestamp).toBeGreaterThan(0);
+    expect(err.toUserMessage()).toContain('try again');
+  });
+
+  it('toJSON serializes correctly', () => {
+    const err = new OPCError('test', { code: 'T1' });
+    const json = err.toJSON();
+    expect(json.name).toBe('OPCError');
+    expect(json.code).toBe('T1');
+  });
+
+  it('ProviderError includes provider', () => {
+    const err = new ProviderError('openai', 'API key invalid', { statusCode: 401 });
+    expect(err.provider).toBe('openai');
+    expect(err.statusCode).toBe(401);
+    expect(err.code).toBe('OPC_PROVIDER_ERROR');
+    expect(err instanceof OPCError).toBe(true);
+  });
+
+  it('ValidationError includes errors array', () => {
+    const err = new ValidationError('Invalid config', ['missing name', 'bad version'], 'metadata');
+    expect(err.errors).toEqual(['missing name', 'bad version']);
+    expect(err.field).toBe('metadata');
+  });
+
+  it('ConfigError', () => {
+    const err = new ConfigError('Missing oad.yaml');
+    expect(err.code).toBe('OPC_CONFIG_ERROR');
+  });
+
+  it('ChannelError', () => {
+    const err = new ChannelError('web', 'Port in use');
+    expect(err.channelType).toBe('web');
+  });
+
+  it('PluginError', () => {
+    const err = new PluginError('my-plugin', 'Init failed');
+    expect(err.pluginName).toBe('my-plugin');
+  });
+
+  it('RateLimitError', () => {
+    const err = new RateLimitError(undefined, 5000);
+    expect(err.retryAfterMs).toBe(5000);
+    expect(err.toUserMessage()).toContain('5 seconds');
+  });
+
+  it('SecurityError', () => {
+    const err = new SecurityError('Blocked');
+    expect(err.code).toBe('OPC_SECURITY_ERROR');
+  });
+
+  it('TimeoutError', () => {
+    const err = new TimeoutError('llm-call', 30000);
+    expect(err.message).toContain('30000ms');
+  });
+
+  it('wrapError wraps unknown errors', () => {
+    const wrapped = wrapError('string error');
+    expect(wrapped instanceof OPCError).toBe(true);
+    expect(wrapped.message).toBe('string error');
+
+    const native = wrapError(new Error('native'));
+    expect(native.message).toBe('native');
+
+    const existing = new ProviderError('x', 'y');
+    expect(wrapError(existing)).toBe(existing);
+  });
+
+  it('formatErrorForUser returns clean message', () => {
+    expect(formatErrorForUser(new RateLimitError())).toContain('Rate limit');
+    expect(formatErrorForUser(new Error('raw'))).toBe('raw');
+    expect(formatErrorForUser('string')).toBe('string');
+  });
+});

package/tests/hitl.test.ts

@@ -1,71 +1,71 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { HITLManager } from '../src/core/hitl';
-
-describe('HITLManager', () => {
-  let hitl: HITLManager;
-
-  beforeEach(() => {
-    hitl = new HITLManager({
-      requireApproval: ['delete', 'deploy'],
-      defaultTimeoutMs: 500,
-      defaultAction: 'deny',
-    });
-  });
-
-  it('should check if action needs approval', () => {
-    expect(hitl.needsApproval('delete')).toBe(true);
-    expect(hitl.needsApproval('read')).toBe(false);
-  });
-
-  it('should approve via handler', async () => {
-    hitl.setHandler(async (req) => ({
-      requestId: req.id,
-      decision: 'approve',
-      respondedAt: Date.now(),
-      timedOut: false,
-    }));
-
-    const response = await hitl.requestApproval('delete', 'Delete record #123');
-    expect(response.decision).toBe('approve');
-    expect(response.timedOut).toBe(false);
-  });
-
-  it('should deny via handler', async () => {
-    hitl.setHandler(async (req) => ({
-      requestId: req.id,
-      decision: 'deny',
-      respondedAt: Date.now(),
-      timedOut: false,
-    }));
-
-    const response = await hitl.requestApproval('deploy', 'Deploy to production');
-    expect(response.decision).toBe('deny');
-  });
-
-  it('should timeout with default action', async () => {
-    // No handler, no manual response → timeout
-    const response = await hitl.requestApproval('delete', 'Test timeout');
-    expect(response.timedOut).toBe(true);
-    expect(response.decision).toBe('deny'); // default action
-  });
-
-  it('should handle manual respond', async () => {
-    const promise = hitl.requestApproval('delete', 'Manual test');
-    const pending = hitl.getPending();
-    expect(pending).toHaveLength(1);
-    
-    hitl.respond(pending[0].id, 'approve', 'admin');
-    const response = await promise;
-    expect(response.decision).toBe('approve');
-    expect(response.respondedBy).toBe('admin');
-  });
-
-  it('should return false for unknown respond', () => {
-    expect(hitl.respond('unknown-id', 'approve')).toBe(false);
-  });
-
-  it('should match wildcard approval', () => {
-    const wildcard = new HITLManager({ requireApproval: ['*'] });
-    expect(wildcard.needsApproval('anything')).toBe(true);
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HITLManager } from '../src/core/hitl';
+
+describe('HITLManager', () => {
+  let hitl: HITLManager;
+
+  beforeEach(() => {
+    hitl = new HITLManager({
+      requireApproval: ['delete', 'deploy'],
+      defaultTimeoutMs: 500,
+      defaultAction: 'deny',
+    });
+  });
+
+  it('should check if action needs approval', () => {
+    expect(hitl.needsApproval('delete')).toBe(true);
+    expect(hitl.needsApproval('read')).toBe(false);
+  });
+
+  it('should approve via handler', async () => {
+    hitl.setHandler(async (req) => ({
+      requestId: req.id,
+      decision: 'approve',
+      respondedAt: Date.now(),
+      timedOut: false,
+    }));
+
+    const response = await hitl.requestApproval('delete', 'Delete record #123');
+    expect(response.decision).toBe('approve');
+    expect(response.timedOut).toBe(false);
+  });
+
+  it('should deny via handler', async () => {
+    hitl.setHandler(async (req) => ({
+      requestId: req.id,
+      decision: 'deny',
+      respondedAt: Date.now(),
+      timedOut: false,
+    }));
+
+    const response = await hitl.requestApproval('deploy', 'Deploy to production');
+    expect(response.decision).toBe('deny');
+  });
+
+  it('should timeout with default action', async () => {
+    // No handler, no manual response → timeout
+    const response = await hitl.requestApproval('delete', 'Test timeout');
+    expect(response.timedOut).toBe(true);
+    expect(response.decision).toBe('deny'); // default action
+  });
+
+  it('should handle manual respond', async () => {
+    const promise = hitl.requestApproval('delete', 'Manual test');
+    const pending = hitl.getPending();
+    expect(pending).toHaveLength(1);
+    
+    hitl.respond(pending[0].id, 'approve', 'admin');
+    const response = await promise;
+    expect(response.decision).toBe('approve');
+    expect(response.respondedBy).toBe('admin');
+  });
+
+  it('should return false for unknown respond', () => {
+    expect(hitl.respond('unknown-id', 'approve')).toBe(false);
+  });
+
+  it('should match wildcard approval', () => {
+    const wildcard = new HITLManager({ requireApproval: ['*'] });
+    expect(wildcard.needsApproval('anything')).toBe(true);
+  });
+});