opc-agent 4.1.0 → 4.1.1

package/tests/api-server.test.ts

@@ -1,148 +1,148 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { APIServer } from '../src/core/api-server';
-
-function createMockAgent(overrides: any = {}) {
-  return {
-    name: 'test-agent',
-    state: 'running',
-    config: { model: 'test-model', name: 'test-agent' },
-    chat: async (msg: string) => `echo: ${msg}`,
-    ...overrides,
-  };
-}
-
-async function request(port: number, method: string, path: string, body?: any, headers?: Record<string, string>) {
-  const res = await fetch(`http://127.0.0.1:${port}${path}`, {
-    method,
-    headers: { 'Content-Type': 'application/json', ...headers },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  return res;
-}
-
-describe('APIServer', () => {
-  let server: APIServer;
-  const port = 19876;
-
-  beforeAll(async () => {
-    server = new APIServer({ port, host: '127.0.0.1', agent: createMockAgent() });
-    await server.start();
-  });
-  afterAll(async () => { await server.stop(); });
-
-  it('GET /health returns ok', async () => {
-    const res = await request(port, 'GET', '/health');
-    expect(res.status).toBe(200);
-    const data: any = await res.json();
-    expect(data.status).toBe('ok');
-  });
-
-  it('GET /v1/models lists models', async () => {
-    const res = await request(port, 'GET', '/v1/models');
-    const data: any = await res.json();
-    expect(data.object).toBe('list');
-    expect(data.data[0].id).toBe('test-model');
-  });
-
-  it('GET /v1/agent/status returns agent info', async () => {
-    const res = await request(port, 'GET', '/v1/agent/status');
-    const data: any = await res.json();
-    expect(data.name).toBe('test-agent');
-    expect(data.state).toBe('running');
-  });
-
-  it('POST /v1/chat/completions non-streaming', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', {
-      model: 'test-model',
-      messages: [{ role: 'user', content: 'hello' }],
-    });
-    expect(res.status).toBe(200);
-    const data: any = await res.json();
-    expect(data.choices[0].message.content).toBe('echo: hello');
-    expect(data.choices[0].finish_reason).toBe('stop');
-    expect(data.id).toMatch(/^chatcmpl-/);
-    expect(data.object).toBe('chat.completion');
-  });
-
-  it('POST /v1/chat/completions streaming', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', {
-      messages: [{ role: 'user', content: 'hi' }],
-      stream: true,
-    });
-    expect(res.status).toBe(200);
-    expect(res.headers.get('content-type')).toBe('text/event-stream');
-    const text = await res.text();
-    expect(text).toContain('data: ');
-    expect(text).toContain('[DONE]');
-    // Parse SSE chunks
-    const chunks = text.split('\n').filter(l => l.startsWith('data: ') && !l.includes('[DONE]'));
-    expect(chunks.length).toBeGreaterThan(0);
-    const first = JSON.parse(chunks[0].slice(6));
-    expect(first.object).toBe('chat.completion.chunk');
-  });
-
-  it('POST /v1/chat/completions rejects missing messages', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', { model: 'x' });
-    expect(res.status).toBe(400);
-    const data: any = await res.json();
-    expect(data.error.type).toBe('invalid_request_error');
-  });
-
-  it('POST /v1/chat/completions rejects invalid JSON', async () => {
-    const res = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: 'not json',
-    });
-    expect(res.status).toBe(400);
-  });
-
-  it('OPTIONS returns CORS headers', async () => {
-    const res = await fetch(`http://127.0.0.1:${port}/v1/models`, { method: 'OPTIONS' });
-    expect(res.status).toBe(204);
-    expect(res.headers.get('access-control-allow-origin')).toBe('*');
-  });
-
-  it('unknown route returns 404', async () => {
-    const res = await request(port, 'GET', '/v1/unknown');
-    expect(res.status).toBe(404);
-    const data: any = await res.json();
-    expect(data.error.code).toBe(404);
-  });
-
-  it('POST /v1/embeddings returns 501 without embed provider', async () => {
-    const res = await request(port, 'POST', '/v1/embeddings', { input: 'hello' });
-    expect(res.status).toBe(501);
-  });
-
-  it('POST /v1/embeddings rejects missing input', async () => {
-    const res = await request(port, 'POST', '/v1/embeddings', { model: 'x' });
-    expect(res.status).toBe(400);
-  });
-});
-
-describe('APIServer with auth', () => {
-  let server: APIServer;
-  const port = 19877;
-
-  beforeAll(async () => {
-    server = new APIServer({ port, host: '127.0.0.1', apiKey: 'secret-key', agent: createMockAgent() });
-    await server.start();
-  });
-  afterAll(async () => { await server.stop(); });
-
-  it('rejects unauthenticated requests', async () => {
-    const res = await request(port, 'GET', '/v1/models');
-    expect(res.status).toBe(401);
-  });
-
-  it('accepts valid Bearer token', async () => {
-    const res = await request(port, 'GET', '/v1/models', undefined, { Authorization: 'Bearer secret-key' });
-    expect(res.status).toBe(200);
-  });
-
-  it('health check works without auth', async () => {
-    const res = await request(port, 'GET', '/health');
-    expect(res.status).toBe(200);
-  });
-});
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { APIServer } from '../src/core/api-server';
+
+function createMockAgent(overrides: any = {}) {
+  return {
+    name: 'test-agent',
+    state: 'running',
+    config: { model: 'test-model', name: 'test-agent' },
+    chat: async (msg: string) => `echo: ${msg}`,
+    ...overrides,
+  };
+}
+
+async function request(port: number, method: string, path: string, body?: any, headers?: Record<string, string>) {
+  const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+    method,
+    headers: { 'Content-Type': 'application/json', ...headers },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  return res;
+}
+
+describe('APIServer', () => {
+  let server: APIServer;
+  const port = 19876;
+
+  beforeAll(async () => {
+    server = new APIServer({ port, host: '127.0.0.1', agent: createMockAgent() });
+    await server.start();
+  });
+  afterAll(async () => { await server.stop(); });
+
+  it('GET /health returns ok', async () => {
+    const res = await request(port, 'GET', '/health');
+    expect(res.status).toBe(200);
+    const data: any = await res.json();
+    expect(data.status).toBe('ok');
+  });
+
+  it('GET /v1/models lists models', async () => {
+    const res = await request(port, 'GET', '/v1/models');
+    const data: any = await res.json();
+    expect(data.object).toBe('list');
+    expect(data.data[0].id).toBe('test-model');
+  });
+
+  it('GET /v1/agent/status returns agent info', async () => {
+    const res = await request(port, 'GET', '/v1/agent/status');
+    const data: any = await res.json();
+    expect(data.name).toBe('test-agent');
+    expect(data.state).toBe('running');
+  });
+
+  it('POST /v1/chat/completions non-streaming', async () => {
+    const res = await request(port, 'POST', '/v1/chat/completions', {
+      model: 'test-model',
+      messages: [{ role: 'user', content: 'hello' }],
+    });
+    expect(res.status).toBe(200);
+    const data: any = await res.json();
+    expect(data.choices[0].message.content).toBe('echo: hello');
+    expect(data.choices[0].finish_reason).toBe('stop');
+    expect(data.id).toMatch(/^chatcmpl-/);
+    expect(data.object).toBe('chat.completion');
+  });
+
+  it('POST /v1/chat/completions streaming', async () => {
+    const res = await request(port, 'POST', '/v1/chat/completions', {
+      messages: [{ role: 'user', content: 'hi' }],
+      stream: true,
+    });
+    expect(res.status).toBe(200);
+    expect(res.headers.get('content-type')).toBe('text/event-stream');
+    const text = await res.text();
+    expect(text).toContain('data: ');
+    expect(text).toContain('[DONE]');
+    // Parse SSE chunks
+    const chunks = text.split('\n').filter(l => l.startsWith('data: ') && !l.includes('[DONE]'));
+    expect(chunks.length).toBeGreaterThan(0);
+    const first = JSON.parse(chunks[0].slice(6));
+    expect(first.object).toBe('chat.completion.chunk');
+  });
+
+  it('POST /v1/chat/completions rejects missing messages', async () => {
+    const res = await request(port, 'POST', '/v1/chat/completions', { model: 'x' });
+    expect(res.status).toBe(400);
+    const data: any = await res.json();
+    expect(data.error.type).toBe('invalid_request_error');
+  });
+
+  it('POST /v1/chat/completions rejects invalid JSON', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'not json',
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it('OPTIONS returns CORS headers', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/v1/models`, { method: 'OPTIONS' });
+    expect(res.status).toBe(204);
+    expect(res.headers.get('access-control-allow-origin')).toBe('*');
+  });
+
+  it('unknown route returns 404', async () => {
+    const res = await request(port, 'GET', '/v1/unknown');
+    expect(res.status).toBe(404);
+    const data: any = await res.json();
+    expect(data.error.code).toBe(404);
+  });
+
+  it('POST /v1/embeddings returns 501 without embed provider', async () => {
+    const res = await request(port, 'POST', '/v1/embeddings', { input: 'hello' });
+    expect(res.status).toBe(501);
+  });
+
+  it('POST /v1/embeddings rejects missing input', async () => {
+    const res = await request(port, 'POST', '/v1/embeddings', { model: 'x' });
+    expect(res.status).toBe(400);
+  });
+});
+
+describe('APIServer with auth', () => {
+  let server: APIServer;
+  const port = 19877;
+
+  beforeAll(async () => {
+    server = new APIServer({ port, host: '127.0.0.1', apiKey: 'secret-key', agent: createMockAgent() });
+    await server.start();
+  });
+  afterAll(async () => { await server.stop(); });
+
+  it('rejects unauthenticated requests', async () => {
+    const res = await request(port, 'GET', '/v1/models');
+    expect(res.status).toBe(401);
+  });
+
+  it('accepts valid Bearer token', async () => {
+    const res = await request(port, 'GET', '/v1/models', undefined, { Authorization: 'Bearer secret-key' });
+    expect(res.status).toBe(200);
+  });
+
+  it('health check works without auth', async () => {
+    const res = await request(port, 'GET', '/health');
+    expect(res.status).toBe(200);
+  });
+});

package/tests/approvals.test.ts

@@ -1,89 +1,89 @@
-import { describe, it, expect } from 'vitest';
-import { ExecApprovalManager } from '../src/security/approvals';
-
-describe('ExecApprovalManager', () => {
-  it('should default to elevated-only policy', () => {
-    const mgr = new ExecApprovalManager();
-    expect(mgr.getPolicy()).toBe('elevated-only');
-    mgr.destroy();
-  });
-
-  it('should require approval for elevated commands in elevated-only mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'elevated-only' });
-    expect(mgr.needsApproval('ls', true)).toBe(true);
-    expect(mgr.needsApproval('ls', false)).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should always require approval in always mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'always' });
-    expect(mgr.needsApproval('ls', false)).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should never require approval in never mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'never' });
-    expect(mgr.needsApproval('rm -rf /', true)).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should skip approval for allowlisted commands', () => {
-    const mgr = new ExecApprovalManager({ policy: 'allowlist', allowedCommands: ['git ', 'npm test'] });
-    expect(mgr.needsApproval('git pull', false)).toBe(false);
-    expect(mgr.needsApproval('rm -rf /', false)).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should create and approve requests', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('sudo reboot', true);
-    expect(req.status).toBe('pending');
-    expect(mgr.getPending()).toHaveLength(1);
-    const approved = mgr.approve(req.id, 'admin');
-    expect(approved.status).toBe('approved');
-    expect(mgr.getPending()).toHaveLength(0);
-    expect(mgr.getHistory()).toHaveLength(1);
-    mgr.destroy();
-  });
-
-  it('should deny requests', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('rm -rf /', true);
-    const denied = mgr.deny(req.id, 'admin', 'too dangerous');
-    expect(denied.status).toBe('denied');
-    expect(denied.reason).toBe('too dangerous');
-    mgr.destroy();
-  });
-
-  it('should throw on double approve', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('test', false);
-    mgr.approve(req.id, 'admin');
-    expect(() => mgr.approve(req.id, 'admin')).toThrow();
-    mgr.destroy();
-  });
-
-  it('should expire pending requests', () => {
-    const mgr = new ExecApprovalManager({ expiryMs: 1 });
-    const req = mgr.request('test', false);
-    // Wait a tick then check
-    return new Promise<void>(resolve => {
-      setTimeout(() => {
-        mgr.checkExpiry();
-        expect(mgr.getPending()).toHaveLength(0);
-        const found = mgr.getRequest(req.id);
-        expect(found?.status).toBe('expired');
-        mgr.destroy();
-        resolve();
-      }, 10);
-    });
-  });
-
-  it('should fire onRequest callback', () => {
-    let called = false;
-    const mgr = new ExecApprovalManager({ onRequest: () => { called = true; } });
-    mgr.request('test', false);
-    expect(called).toBe(true);
-    mgr.destroy();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ExecApprovalManager } from '../src/security/approvals';
+
+describe('ExecApprovalManager', () => {
+  it('should default to elevated-only policy', () => {
+    const mgr = new ExecApprovalManager();
+    expect(mgr.getPolicy()).toBe('elevated-only');
+    mgr.destroy();
+  });
+
+  it('should require approval for elevated commands in elevated-only mode', () => {
+    const mgr = new ExecApprovalManager({ policy: 'elevated-only' });
+    expect(mgr.needsApproval('ls', true)).toBe(true);
+    expect(mgr.needsApproval('ls', false)).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should always require approval in always mode', () => {
+    const mgr = new ExecApprovalManager({ policy: 'always' });
+    expect(mgr.needsApproval('ls', false)).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should never require approval in never mode', () => {
+    const mgr = new ExecApprovalManager({ policy: 'never' });
+    expect(mgr.needsApproval('rm -rf /', true)).toBe(false);
+    mgr.destroy();
+  });
+
+  it('should skip approval for allowlisted commands', () => {
+    const mgr = new ExecApprovalManager({ policy: 'allowlist', allowedCommands: ['git ', 'npm test'] });
+    expect(mgr.needsApproval('git pull', false)).toBe(false);
+    expect(mgr.needsApproval('rm -rf /', false)).toBe(true);
+    mgr.destroy();
+  });
+
+  it('should create and approve requests', () => {
+    const mgr = new ExecApprovalManager();
+    const req = mgr.request('sudo reboot', true);
+    expect(req.status).toBe('pending');
+    expect(mgr.getPending()).toHaveLength(1);
+    const approved = mgr.approve(req.id, 'admin');
+    expect(approved.status).toBe('approved');
+    expect(mgr.getPending()).toHaveLength(0);
+    expect(mgr.getHistory()).toHaveLength(1);
+    mgr.destroy();
+  });
+
+  it('should deny requests', () => {
+    const mgr = new ExecApprovalManager();
+    const req = mgr.request('rm -rf /', true);
+    const denied = mgr.deny(req.id, 'admin', 'too dangerous');
+    expect(denied.status).toBe('denied');
+    expect(denied.reason).toBe('too dangerous');
+    mgr.destroy();
+  });
+
+  it('should throw on double approve', () => {
+    const mgr = new ExecApprovalManager();
+    const req = mgr.request('test', false);
+    mgr.approve(req.id, 'admin');
+    expect(() => mgr.approve(req.id, 'admin')).toThrow();
+    mgr.destroy();
+  });
+
+  it('should expire pending requests', () => {
+    const mgr = new ExecApprovalManager({ expiryMs: 1 });
+    const req = mgr.request('test', false);
+    // Wait a tick then check
+    return new Promise<void>(resolve => {
+      setTimeout(() => {
+        mgr.checkExpiry();
+        expect(mgr.getPending()).toHaveLength(0);
+        const found = mgr.getRequest(req.id);
+        expect(found?.status).toBe('expired');
+        mgr.destroy();
+        resolve();
+      }, 10);
+    });
+  });
+
+  it('should fire onRequest callback', () => {
+    let called = false;
+    const mgr = new ExecApprovalManager({ onRequest: () => { called = true; } });
+    mgr.request('test', false);
+    expect(called).toBe(true);
+    mgr.destroy();
+  });
+});

package/tests/audio.test.ts

@@ -1,40 +1,40 @@
-import { describe, it, expect } from 'vitest';
-import { AudioProcessor } from '../src/core/audio';
-
-describe('AudioProcessor', () => {
-  it('should detect WAV format', () => {
-    const wav = Buffer.from('RIFF\x00\x00\x00\x00WAVEfmt ');
-    expect(AudioProcessor.detectFormat(wav)).toBe('wav');
-  });
-
-  it('should detect MP3 format (ID3)', () => {
-    const mp3 = Buffer.from('ID3\x04\x00\x00\x00\x00\x00\x00');
-    expect(AudioProcessor.detectFormat(mp3)).toBe('mp3');
-  });
-
-  it('should return unknown for unrecognized format', () => {
-    const unknown = Buffer.from('NOTAFORMAT');
-    expect(AudioProcessor.detectFormat(unknown)).toBe('unknown');
-  });
-
-  it('should split buffer into chunks', () => {
-    const buf = Buffer.alloc(100, 0x42);
-    const chunks = AudioProcessor.split(buf, 30);
-    expect(chunks).toHaveLength(4);
-    expect(chunks[0].length).toBe(30);
-    expect(chunks[3].length).toBe(10);
-  });
-
-  it('should throw without provider on transcribe', async () => {
-    const proc = new AudioProcessor();
-    await expect(proc.transcribe(Buffer.alloc(0))).rejects.toThrow('No transcribe provider');
-  });
-
-  it('should call transcribe provider', async () => {
-    const proc = new AudioProcessor({
-      transcribe: async () => ({ text: 'hello world' }),
-    });
-    const result = await proc.transcribe(Buffer.alloc(10));
-    expect(result.text).toBe('hello world');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { AudioProcessor } from '../src/core/audio';
+
+describe('AudioProcessor', () => {
+  it('should detect WAV format', () => {
+    const wav = Buffer.from('RIFF\x00\x00\x00\x00WAVEfmt ');
+    expect(AudioProcessor.detectFormat(wav)).toBe('wav');
+  });
+
+  it('should detect MP3 format (ID3)', () => {
+    const mp3 = Buffer.from('ID3\x04\x00\x00\x00\x00\x00\x00');
+    expect(AudioProcessor.detectFormat(mp3)).toBe('mp3');
+  });
+
+  it('should return unknown for unrecognized format', () => {
+    const unknown = Buffer.from('NOTAFORMAT');
+    expect(AudioProcessor.detectFormat(unknown)).toBe('unknown');
+  });
+
+  it('should split buffer into chunks', () => {
+    const buf = Buffer.alloc(100, 0x42);
+    const chunks = AudioProcessor.split(buf, 30);
+    expect(chunks).toHaveLength(4);
+    expect(chunks[0].length).toBe(30);
+    expect(chunks[3].length).toBe(10);
+  });
+
+  it('should throw without provider on transcribe', async () => {
+    const proc = new AudioProcessor();
+    await expect(proc.transcribe(Buffer.alloc(0))).rejects.toThrow('No transcribe provider');
+  });
+
+  it('should call transcribe provider', async () => {
+    const proc = new AudioProcessor({
+      transcribe: async () => ({ text: 'hello world' }),
+    });
+    const result = await proc.transcribe(Buffer.alloc(10));
+    expect(result.text).toBe('hello world');
+  });
+});