opc-agent 3.0.1 → 4.0.0

package/src/tools/builtin/vision.ts

@@ -0,0 +1,64 @@
+import type { MCPTool, MCPToolResult } from '../mcp';
+import { VisionManager } from '../../core/vision';
+import type { ImageInput } from '../../core/vision';
+
+const manager = new VisionManager();
+
+export const visionAnalyzeTool: MCPTool = {
+  name: 'vision_analyze',
+  description: 'Analyze an image using vision AI. Provide image as URL or base64.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      image_url: { type: 'string', description: 'URL of the image to analyze' },
+      image_base64: { type: 'string', description: 'Base64-encoded image data' },
+      prompt: { type: 'string', description: 'Optional prompt for analysis' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const imgInput: ImageInput = input.image_url
+      ? { type: 'url', data: input.image_url as string }
+      : { type: 'base64', data: input.image_base64 as string };
+    const result = await manager.analyze(imgInput, input.prompt as string | undefined);
+    return { content: JSON.stringify(result) };
+  },
+};
+
+export const visionExtractTextTool: MCPTool = {
+  name: 'vision_extract_text',
+  description: 'Extract text (OCR) from an image.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      image_url: { type: 'string', description: 'URL of the image' },
+      image_base64: { type: 'string', description: 'Base64-encoded image data' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const imgInput: ImageInput = input.image_url
+      ? { type: 'url', data: input.image_url as string }
+      : { type: 'base64', data: input.image_base64 as string };
+    const text = await manager.extractText(imgInput);
+    return { content: text };
+  },
+};
+
+export const visionCompareTool: MCPTool = {
+  name: 'vision_compare',
+  description: 'Compare multiple images.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      image_urls: { type: 'array', items: { type: 'string' }, description: 'URLs of images to compare' },
+      prompt: { type: 'string', description: 'Optional comparison prompt' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const urls = input.image_urls as string[];
+    const images: ImageInput[] = urls.map(url => ({ type: 'url' as const, data: url }));
+    const result = await manager.compareImages(images, input.prompt as string | undefined);
+    return { content: result };
+  },
+};
+
+export const visionTools: MCPTool[] = [visionAnalyzeTool, visionExtractTextTool, visionCompareTool];

package/tests/api-server.test.ts

@@ -0,0 +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);
+  });
+});

package/tests/approvals.test.ts

@@ -0,0 +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();
+  });
+});

package/tests/audio.test.ts

@@ -0,0 +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');
+  });
+});

package/tests/browser.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { BrowserManager } from '../src/tools/builtin/browser';
+
+// Mock playwright
+const mockPage = {
+  goto: vi.fn().mockResolvedValue(undefined),
+  title: vi.fn().mockResolvedValue('Test Page'),
+  url: vi.fn().mockReturnValue('https://example.com'),
+  innerText: vi.fn().mockResolvedValue('Hello World'),
+  click: vi.fn().mockResolvedValue(undefined),
+  fill: vi.fn().mockResolvedValue(undefined),
+  screenshot: vi.fn().mockResolvedValue(Buffer.from('fake-png')),
+  $$eval: vi.fn().mockResolvedValue([]),
+  evaluate: vi.fn().mockResolvedValue('result'),
+  waitForSelector: vi.fn().mockResolvedValue(true),
+  goBack: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockContext = {
+  newPage: vi.fn().mockResolvedValue(mockPage),
+};
+
+const mockBrowser = {
+  newContext: vi.fn().mockResolvedValue(mockContext),
+  close: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockPlaywright = () => ({
+  chromium: {
+    launch: vi.fn().mockResolvedValue(mockBrowser),
+  },
+});
+
+describe('BrowserManager', () => {
+  let manager: BrowserManager;
+
+  beforeEach(() => {
+    manager = new BrowserManager(mockPlaywright);
+    vi.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    await manager.close();
+  });
+
+  it('lazy initializes browser on first call', async () => {
+    await manager.ensureBrowser();
+    expect(mockBrowser.newContext).toHaveBeenCalledOnce();
+  });
+
+  it('reuses browser on subsequent calls', async () => {
+    await manager.ensureBrowser();
+    await manager.ensureBrowser();
+    expect(mockBrowser.newContext).toHaveBeenCalledOnce();
+  });
+
+  it('navigate returns title, text, url', async () => {
+    const result = await manager.navigate('https://example.com');
+    expect(result.title).toBe('Test Page');
+    expect(result.text).toBe('Hello World');
+    expect(result.url).toBe('https://example.com');
+    expect(mockPage.goto).toHaveBeenCalledWith('https://example.com', expect.any(Object));
+  });
+
+  it('click calls page.click with selector', async () => {
+    await manager.click('#btn');
+    expect(mockPage.click).toHaveBeenCalledWith('#btn', expect.any(Object));
+  });
+
+  it('type calls page.fill', async () => {
+    await manager.type('#input', 'hello');
+    expect(mockPage.fill).toHaveBeenCalledWith('#input', 'hello', expect.any(Object));
+  });
+
+  it('screenshot returns base64', async () => {
+    const result = await manager.screenshot();
+    expect(typeof result).toBe('string');
+    expect(result).toBe(Buffer.from('fake-png').toString('base64'));
+  });
+
+  it('extract returns text, links, images', async () => {
+    mockPage.$$eval.mockResolvedValueOnce(['https://link1.com']).mockResolvedValueOnce(['img1.png']);
+    const result = await manager.extract();
+    expect(result.text).toBe('Hello World');
+    expect(result.links).toEqual(['https://link1.com']);
+    expect(result.images).toEqual(['img1.png']);
+  });
+
+  it('scroll calls evaluate with direction', async () => {
+    await manager.scroll('down', 300);
+    expect(mockPage.evaluate).toHaveBeenCalled();
+  });
+
+  it('back calls goBack', async () => {
+    await manager.back();
+    expect(mockPage.goBack).toHaveBeenCalled();
+  });
+
+  it('evaluate runs script', async () => {
+    mockPage.evaluate.mockResolvedValueOnce(42);
+    const result = await manager.evaluate('1+1');
+    expect(result).toBe(42);
+  });
+
+  it('getImages calls $$eval', async () => {
+    mockPage.$$eval.mockResolvedValueOnce([{ src: 'a.png', alt: 'A' }]);
+    const images = await manager.getImages();
+    expect(images).toEqual([{ src: 'a.png', alt: 'A' }]);
+  });
+
+  it('waitFor returns true when found', async () => {
+    const result = await manager.waitFor('.test');
+    expect(result).toBe(true);
+  });
+
+  it('waitFor returns false on timeout', async () => {
+    mockPage.waitForSelector.mockRejectedValueOnce(new Error('timeout'));
+    const result = await manager.waitFor('.missing', 100);
+    expect(result).toBe(false);
+  });
+
+  it('close cleans up browser', async () => {
+    await manager.ensureBrowser();
+    await manager.close();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('close is safe to call without browser', async () => {
+    await manager.close(); // should not throw
+  });
+
+  it('throws helpful error when playwright not installed', async () => {
+    const noPlaywright = new BrowserManager();
+    await expect(noPlaywright.ensureBrowser()).rejects.toThrow('Install playwright: npm i playwright');
+  });
+});
+
+describe('Browser tool parameter validation', () => {
+  it('browser_navigate requires url', async () => {
+    const { browserNavigateTool } = await import('../src/tools/builtin/browser');
+    const result = await browserNavigateTool.execute({});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('url');
+  });
+
+  it('browser_click requires selector', async () => {
+    const { browserClickTool } = await import('../src/tools/builtin/browser');
+    const result = await browserClickTool.execute({});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('selector');
+  });
+
+  it('browser_type requires selector and text', async () => {
+    const { browserTypeTool } = await import('../src/tools/builtin/browser');
+    const result = await browserTypeTool.execute({});
+    expect(result.isError).toBe(true);
+  });
+
+  it('browser_eval requires script', async () => {
+    const { browserEvalTool } = await import('../src/tools/builtin/browser');
+    const result = await browserEvalTool.execute({});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('script');
+  });
+
+  it('browser_wait requires selector', async () => {
+    const { browserWaitTool } = await import('../src/tools/builtin/browser');
+    const result = await browserWaitTool.execute({});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('selector');
+  });
+
+  it('browser_scroll requires direction', async () => {
+    const { browserScrollTool } = await import('../src/tools/builtin/browser');
+    const result = await browserScrollTool.execute({});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('direction');
+  });
+});