opc-agent 3.0.1 → 4.0.1

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

package/tests/builtin-tools.test.ts

@@ -1,83 +1,83 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
-import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
-
-describe('getBuiltinTools', () => {
-  it('returns 4 tools', () => {
-    const tools = getBuiltinTools();
-    expect(tools).toHaveLength(4);
-    const names = tools.map(t => t.name);
-    expect(names).toContain('file_operations');
-    expect(names).toContain('web_fetch');
-    expect(names).toContain('shell_exec');
-    expect(names).toContain('datetime');
-  });
-
-  it('getBuiltinToolsByName filters correctly', () => {
-    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
-    expect(tools).toHaveLength(2);
-  });
-
-  it('getBuiltinToolsByName with no args returns all', () => {
-    expect(getBuiltinToolsByName()).toHaveLength(4);
-  });
-});
-
-describe('file_operations tool', () => {
-  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
-  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
-  const testFile = `tmp-test-${Date.now()}.txt`;
-
-  afterAll(() => {
-    try { require('fs').unlinkSync(testFile); } catch {}
-  });
-
-  it('write and read a file', async () => {
-    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
-    expect(writeRes.isError).toBe(false);
-
-    const readRes = await fileTool.execute({ action: 'read', path: testFile });
-    expect(readRes.isError).toBe(false);
-    expect(readRes.content).toBe('hello');
-  });
-
-  it('list files', async () => {
-    const res = await fileTool.execute({ action: 'list', path: '.' });
-    expect(res.isError).toBe(false);
-    expect(res.content).toContain('package.json');
-  });
-
-  it('exists check', async () => {
-    const res = await fileTool.execute({ action: 'exists', path: testFile });
-    expect(res.content).toBe('true');
-
-    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
-    expect(res2.content).toBe('false');
-  });
-
-  it('rejects path outside workspace', async () => {
-    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
-    expect(res.isError).toBe(true);
-  });
-});
-
-describe('datetime tool', () => {
-  it('returns valid JSON with iso field', async () => {
-    const res = await datetimeTool.execute({});
-    expect(res.isError).toBe(false);
-    const parsed = JSON.parse(res.content);
-    expect(parsed.iso).toBeDefined();
-    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
-  });
-});
-
-describe('shell_exec tool', () => {
-  it('runs a command', async () => {
-    const res = await shellTool.execute({ command: 'echo hello' });
-    expect(res.isError).toBe(false);
-    expect(res.content).toContain('hello');
-  });
-});
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getBuiltinTools, getBuiltinToolsByName } from '../src/tools/builtin';
+import { fileTool, shellTool, datetimeTool } from '../src/tools/builtin';
+
+describe('getBuiltinTools', () => {
+  it('returns 17 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(31);
+    const names = tools.map(t => t.name);
+    expect(names).toContain('file_operations');
+    expect(names).toContain('web_fetch');
+    expect(names).toContain('shell_exec');
+    expect(names).toContain('datetime');
+  });
+
+  it('getBuiltinToolsByName filters correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+
+  it('getBuiltinToolsByName with no args returns all', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(31);
+  });
+});
+
+describe('file_operations tool', () => {
+  // file tool resolves paths relative to cwd, so use relative paths from a temp dir
+  // Actually, it uses process.cwd() as workspace. Let's just test with paths relative to cwd.
+  const testFile = `tmp-test-${Date.now()}.txt`;
+
+  afterAll(() => {
+    try { require('fs').unlinkSync(testFile); } catch {}
+  });
+
+  it('write and read a file', async () => {
+    const writeRes = await fileTool.execute({ action: 'write', path: testFile, content: 'hello' });
+    expect(writeRes.isError).toBe(false);
+
+    const readRes = await fileTool.execute({ action: 'read', path: testFile });
+    expect(readRes.isError).toBe(false);
+    expect(readRes.content).toBe('hello');
+  });
+
+  it('list files', async () => {
+    const res = await fileTool.execute({ action: 'list', path: '.' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('package.json');
+  });
+
+  it('exists check', async () => {
+    const res = await fileTool.execute({ action: 'exists', path: testFile });
+    expect(res.content).toBe('true');
+
+    const res2 = await fileTool.execute({ action: 'exists', path: 'nope-does-not-exist.txt' });
+    expect(res2.content).toBe('false');
+  });
+
+  it('rejects path outside workspace', async () => {
+    const res = await fileTool.execute({ action: 'read', path: '../../etc/passwd' });
+    expect(res.isError).toBe(true);
+  });
+});
+
+describe('datetime tool', () => {
+  it('returns valid JSON with iso field', async () => {
+    const res = await datetimeTool.execute({});
+    expect(res.isError).toBe(false);
+    const parsed = JSON.parse(res.content);
+    expect(parsed.iso).toBeDefined();
+    expect(new Date(parsed.iso).toISOString()).toBe(parsed.iso);
+  });
+});
+
+describe('shell_exec tool', () => {
+  it('runs a command', async () => {
+    const res = await shellTool.execute({ command: 'echo hello' });
+    expect(res.isError).toBe(false);
+    expect(res.content).toContain('hello');
+  });
+});

package/tests/channels-extra.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { WhatsAppChannel } from '../src/channels/whatsapp';
+import { SignalChannel } from '../src/channels/signal';
+import { MatrixChannel } from '../src/channels/matrix';
+import { IMessageChannel } from '../src/channels/imessage';
+import { LINEChannel } from '../src/channels/line';
+import { MSTeamsChannel } from '../src/channels/msteams';
+import { QQChannel } from '../src/channels/qq';
+import { NostrChannel } from '../src/channels/nostr';
+import { SMSChannel } from '../src/channels/sms';
+
+describe('Additional Channels', () => {
+  it('should create WhatsApp channel', () => {
+    const ch = new WhatsAppChannel({ phoneNumber: '+1234567890' });
+    expect(ch.type).toBe('whatsapp');
+  });
+
+  it('should throw on start without deps', async () => {
+    const ch = new SignalChannel();
+    await expect(ch.start()).rejects.toThrow(/Install/);
+  });
+
+  it('should create Matrix channel', () => {
+    const ch = new MatrixChannel({ homeserverUrl: 'https://matrix.org' });
+    expect(ch.type).toBe('matrix');
+  });
+
+  it('should create all channel types', () => {
+    const channels = [
+      new IMessageChannel(),
+      new LINEChannel(),
+      new MSTeamsChannel(),
+      new QQChannel(),
+      new NostrChannel(),
+      new SMSChannel(),
+    ];
+    const types = channels.map(c => c.type);
+    expect(types).toEqual(['imessage', 'line', 'msteams', 'qq', 'nostr', 'sms']);
+  });
+
+  it('should throw on send before start', async () => {
+    const ch = new WhatsAppChannel();
+    await expect(ch.send('123', 'hello')).rejects.toThrow(/not yet connected/);
+  });
+});