opc-agent 4.1.2 → 4.1.4

package/tests/mcp-client.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MCPClient } from '../src/tools/mcp-client';
-
-describe('MCPClient', () => {
-  it('starts with no process', () => {
-    const client = new MCPClient();
-    expect((client as any).process).toBeNull();
-  });
-
-  it('starts with empty buffer', () => {
-    const client = new MCPClient();
-    expect((client as any).buffer).toBe('');
-  });
-
-  it('starts not connected', () => {
-    const client = new MCPClient();
-    expect((client as any).connected).toBe(false);
-  });
-
-  it('nextId starts at 1', () => {
-    const client = new MCPClient();
-    expect((client as any).nextId).toBe(1);
-  });
-
-  it('pending map starts empty', () => {
-    const client = new MCPClient();
-    expect((client as any).pending.size).toBe(0);
-  });
-
-  it('config starts null', () => {
-    const client = new MCPClient();
-    expect((client as any).config).toBeNull();
-  });
-
-  it('processBuffer handles complete JSON line', () => {
-    const client = new MCPClient();
-    const resolve = vi.fn();
-    const reject = vi.fn();
-    (client as any).pending.set(1, { resolve, reject });
-    (client as any).buffer = '{"id":1,"result":{"tools":[]}}\n';
-    (client as any).processBuffer();
-    expect(resolve).toHaveBeenCalledWith({ tools: [] });
-    expect((client as any).pending.size).toBe(0);
-  });
-
-  it('processBuffer handles error response', () => {
-    const client = new MCPClient();
-    const resolve = vi.fn();
-    const reject = vi.fn();
-    (client as any).pending.set(2, { resolve, reject });
-    (client as any).buffer = '{"id":2,"error":{"message":"not found"}}\n';
-    (client as any).processBuffer();
-    expect(reject).toHaveBeenCalled();
-    expect(reject.mock.calls[0][0].message).toBe('not found');
-  });
-
-  it('processBuffer handles partial message (no newline)', () => {
-    const client = new MCPClient();
-    const resolve = vi.fn();
-    (client as any).pending.set(1, { resolve, reject: vi.fn() });
-    (client as any).buffer = '{"id":1,"result":';
-    (client as any).processBuffer();
-    expect(resolve).not.toHaveBeenCalled();
-    // Partial stays in buffer
-    expect((client as any).buffer).toBe('{"id":1,"result":');
-  });
-
-  it('processBuffer handles multiple responses in one chunk', () => {
-    const client = new MCPClient();
-    const r1 = vi.fn(), r2 = vi.fn();
-    (client as any).pending.set(1, { resolve: r1, reject: vi.fn() });
-    (client as any).pending.set(2, { resolve: r2, reject: vi.fn() });
-    (client as any).buffer = '{"id":1,"result":"a"}\n{"id":2,"result":"b"}\n';
-    (client as any).processBuffer();
-    expect(r1).toHaveBeenCalledWith('a');
-    expect(r2).toHaveBeenCalledWith('b');
-  });
-
-  it('processBuffer ignores non-JSON lines', () => {
-    const client = new MCPClient();
-    (client as any).buffer = 'not json at all\n';
-    // Should not throw
-    (client as any).processBuffer();
-  });
-
-  it('processBuffer ignores responses without matching id', () => {
-    const client = new MCPClient();
-    (client as any).buffer = '{"id":999,"result":"orphan"}\n';
-    // Should not throw
-    (client as any).processBuffer();
-  });
-});

package/tests/mcp-server.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MCPServer } from '../src/protocols/mcp/server';
-import { agentToMCPTools, agentToMCPResources } from '../src/protocols/mcp/agent-tools';
-import type { MCPServerToolDefinition, JsonRpcRequest } from '../src/protocols/mcp/types';
-
-function makeRequest(method: string, params?: any, id: number = 1): JsonRpcRequest {
-  return { jsonrpc: '2.0', id, method, params };
-}
-
-describe('MCPServer', () => {
-  let server: MCPServer;
-  const echoTool: MCPServerToolDefinition = {
-    name: 'echo',
-    description: 'Echo back input',
-    inputSchema: {
-      type: 'object',
-      properties: { text: { type: 'string' } },
-      required: ['text'],
-    },
-    handler: async (args) => `Echo: ${args.text}`,
-  };
-
-  beforeEach(() => {
-    server = new MCPServer({ name: 'test-server', version: '1.0.0', tools: [echoTool] });
-  });
-
-  it('initialize response has capabilities', async () => {
-    const res = await server.handleMessage(makeRequest('initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'test', version: '1.0' },
-    }));
-    expect(res).toBeDefined();
-    expect(res!.result.protocolVersion).toBe('2024-11-05');
-    expect(res!.result.capabilities.tools).toBeDefined();
-    expect(res!.result.serverInfo.name).toBe('test-server');
-  });
-
-  it('tools/list returns registered tools', async () => {
-    const res = await server.handleMessage(makeRequest('tools/list'));
-    expect(res!.result.tools).toHaveLength(1);
-    expect(res!.result.tools[0].name).toBe('echo');
-    expect(res!.result.tools[0].description).toBe('Echo back input');
-    expect(res!.result.tools[0].inputSchema).toBeDefined();
-  });
-
-  it('tools/call executes handler and returns content', async () => {
-    const res = await server.handleMessage(makeRequest('tools/call', {
-      name: 'echo', arguments: { text: 'hello' },
-    }));
-    expect(res!.result.content).toHaveLength(1);
-    expect(res!.result.content[0].text).toBe('Echo: hello');
-  });
-
-  it('tools/call returns error for missing tool', async () => {
-    const res = await server.handleMessage(makeRequest('tools/call', {
-      name: 'nonexistent', arguments: {},
-    }));
-    expect(res!.error).toBeDefined();
-    expect(res!.error!.code).toBe(-32001);
-  });
-
-  it('tools/call validates required params', async () => {
-    const res = await server.handleMessage(makeRequest('tools/call', {
-      name: 'echo', arguments: {},
-    }));
-    expect(res!.error).toBeDefined();
-    expect(res!.error!.code).toBe(-32602);
-    expect(res!.error!.message).toContain('text');
-  });
-
-  it('resources/list returns registered resources', async () => {
-    server.addResource({
-      uri: 'test://doc', name: 'TestDoc', description: 'A doc', mimeType: 'text/plain',
-      handler: async () => 'Hello content',
-    });
-    const res = await server.handleMessage(makeRequest('resources/list'));
-    expect(res!.result.resources).toHaveLength(1);
-    expect(res!.result.resources[0].uri).toBe('test://doc');
-  });
-
-  it('resources/read returns resource content', async () => {
-    server.addResource({
-      uri: 'test://doc', name: 'TestDoc', mimeType: 'text/plain',
-      handler: async () => 'Hello content',
-    });
-    const res = await server.handleMessage(makeRequest('resources/read', { uri: 'test://doc' }));
-    expect(res!.result.contents[0].text).toBe('Hello content');
-  });
-
-  it('resources/read returns error for unknown resource', async () => {
-    const res = await server.handleMessage(makeRequest('resources/read', { uri: 'nope://x' }));
-    expect(res!.error).toBeDefined();
-    expect(res!.error!.code).toBe(-32002);
-  });
-
-  it('unknown method returns METHOD_NOT_FOUND', async () => {
-    const res = await server.handleMessage(makeRequest('foo/bar'));
-    expect(res!.error).toBeDefined();
-    expect(res!.error!.code).toBe(-32601);
-  });
-
-  it('JSON-RPC format: response has jsonrpc 2.0 and matching id', async () => {
-    const res = await server.handleMessage(makeRequest('tools/list', {}, 42));
-    expect(res!.jsonrpc).toBe('2.0');
-    expect(res!.id).toBe(42);
-  });
-
-  it('notification (no id) returns null', async () => {
-    const res = await server.handleMessage({
-      jsonrpc: '2.0', method: 'notifications/initialized', params: {},
-    } as any);
-    expect(res).toBeNull();
-  });
-
-  it('prompts/list returns prompts', async () => {
-    server.addPrompt({
-      name: 'summarize', description: 'Summarize text',
-      arguments: [{ name: 'text', required: true }],
-    });
-    const res = await server.handleMessage(makeRequest('prompts/list'));
-    expect(res!.result.prompts).toHaveLength(1);
-    expect(res!.result.prompts[0].name).toBe('summarize');
-  });
-
-  it('addTool/removeTool works dynamically', () => {
-    expect(server.getToolCount()).toBe(1);
-    server.addTool({ name: 'test2', description: 't', inputSchema: {}, handler: async () => 'ok' });
-    expect(server.getToolCount()).toBe(2);
-    server.removeTool('test2');
-    expect(server.getToolCount()).toBe(1);
-  });
-});
-
-describe('agentToMCPTools', () => {
-  it('generates correct tools from agent', () => {
-    const agent = { name: 'test-agent' };
-    const tools = agentToMCPTools(agent);
-    expect(tools.length).toBeGreaterThanOrEqual(3);
-    const names = tools.map(t => t.name);
-    expect(names).toContain('chat');
-    expect(names).toContain('memory_search');
-    expect(names).toContain('memory_store');
-  });
-
-  it('chat tool has correct schema', () => {
-    const tools = agentToMCPTools({ name: 'bot' });
-    const chat = tools.find(t => t.name === 'chat')!;
-    expect(chat.inputSchema.required).toContain('message');
-    expect(chat.description).toContain('bot');
-  });
-
-  it('exposes agent skills as tools', () => {
-    const agent = {
-      name: 'skilled',
-      skills: [{ name: 'translate', description: 'Translate text', execute: async () => 'done' }],
-    };
-    const tools = agentToMCPTools(agent);
-    const skillTool = tools.find(t => t.name === 'skill_translate');
-    expect(skillTool).toBeDefined();
-    expect(skillTool!.description).toContain('Translate');
-  });
-});
-
-describe('agentToMCPResources', () => {
-  it('returns empty array for non-existent dir', () => {
-    const resources = agentToMCPResources({}, '/tmp/nonexistent-agent-dir-xyz');
-    expect(resources).toEqual([]);
-  });
-
-  it('exposes agent files that exist', () => {
-    // Use current project dir which has files
-    const path = require('path');
-    const resources = agentToMCPResources({}, path.resolve(__dirname, '..'));
-    // At minimum no crash; might find some files
-    expect(Array.isArray(resources)).toBe(true);
-  });
-});

package/tests/mcp-servers.test.ts

@@ -1,260 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { listMCPServers, getMCPServer } from '../src/mcp/servers';
-import { createFilesystemServer } from '../src/mcp/servers/filesystem';
-import { createDatabaseServer } from '../src/mcp/servers/database-mcp';
-import { createMemoryServer } from '../src/mcp/servers/memory-mcp';
-import { createCalculatorServer } from '../src/mcp/servers/calculator-mcp';
-import { createDateTimeServer } from '../src/mcp/servers/datetime-mcp';
-import { createJsonServer } from '../src/mcp/servers/json-mcp';
-import { createRegexServer } from '../src/mcp/servers/regex-mcp';
-import { createCryptoServer } from '../src/mcp/servers/crypto-mcp';
-import { generateChatWidget } from '../src/ui/components';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// ─── Registry Tests ─────────────────────────────────
-describe('MCP Server Registry', () => {
-  it('lists 10 servers', () => {
-    const servers = listMCPServers();
-    expect(servers).toHaveLength(10);
-  });
-
-  it('each server has name, description, version, toolCount', () => {
-    for (const s of listMCPServers()) {
-      expect(s.name).toBeTruthy();
-      expect(s.description).toBeTruthy();
-      expect(s.version).toBeTruthy();
-      expect(s.toolCount).toBeGreaterThan(0);
-    }
-  });
-
-  it('getMCPServer returns valid config', () => {
-    const config = getMCPServer('calculator');
-    expect(config.name).toBe('calculator');
-    expect(config.tools!.length).toBeGreaterThan(0);
-  });
-
-  it('getMCPServer throws for unknown', () => {
-    expect(() => getMCPServer('nonexistent')).toThrow('not found');
-  });
-});
-
-// ─── Filesystem Server ──────────────────────────────
-describe('Filesystem MCP', () => {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-fs-'));
-  const server = createFilesystemServer(tmpDir);
-
-  it('tools/list returns 5 tools', () => {
-    expect(server.tools).toHaveLength(5);
-    expect(server.tools!.map(t => t.name)).toContain('fs_read');
-  });
-
-  it('fs_write + fs_read round-trip', async () => {
-    const write = server.tools!.find(t => t.name === 'fs_write')!;
-    const read = server.tools!.find(t => t.name === 'fs_read')!;
-    await write.handler({ path: 'test.txt', content: 'hello mcp' });
-    const result = await read.handler({ path: 'test.txt' });
-    expect(result.content).toBe('hello mcp');
-  });
-
-  it('fs_list returns entries', async () => {
-    const list = server.tools!.find(t => t.name === 'fs_list')!;
-    const result = await list.handler({});
-    expect(result.entries.length).toBeGreaterThan(0);
-  });
-});
-
-// ─── Database MCP ───────────────────────────────────
-describe('Database MCP', () => {
-  const server = createDatabaseServer();
-
-  it('tools/list returns 5 tools', () => {
-    expect(server.tools).toHaveLength(5);
-  });
-
-  it('create table, insert, query', async () => {
-    const create = server.tools!.find(t => t.name === 'db_create_table')!;
-    const insert = server.tools!.find(t => t.name === 'db_insert')!;
-    const query = server.tools!.find(t => t.name === 'db_query')!;
-    await create.handler({ table: 'users', columns: ['name', 'age'] });
-    await insert.handler({ table: 'users', values: { name: 'Alice', age: 30 } });
-    const result = await query.handler({ table: 'users' });
-    expect(result.count).toBe(1);
-    expect(result.rows[0].name).toBe('Alice');
-  });
-});
-
-// ─── Memory MCP ─────────────────────────────────────
-describe('Memory MCP', () => {
-  const server = createMemoryServer();
-
-  it('store and recall', async () => {
-    const store = server.tools!.find(t => t.name === 'memory_store')!;
-    const recall = server.tools!.find(t => t.name === 'memory_recall')!;
-    await store.handler({ key: 'foo', value: 'bar', tags: ['test'] });
-    const result = await recall.handler({ key: 'foo' });
-    expect(result.found).toBe(true);
-    expect(result.value).toBe('bar');
-  });
-
-  it('search by tag', async () => {
-    const search = server.tools!.find(t => t.name === 'memory_search')!;
-    const result = await search.handler({ tag: 'test' });
-    expect(result.count).toBeGreaterThan(0);
-  });
-});
-
-// ─── Calculator MCP ─────────────────────────────────
-describe('Calculator MCP', () => {
-  const server = createCalculatorServer();
-
-  it('evaluate expression', async () => {
-    const calc = server.tools!.find(t => t.name === 'calc_evaluate')!;
-    const result = await calc.handler({ expression: '2 + 3 * 4' });
-    expect(result.result).toBe(14);
-  });
-
-  it('convert temperature', async () => {
-    const conv = server.tools!.find(t => t.name === 'calc_convert')!;
-    const result = await conv.handler({ value: 100, from: 'C', to: 'F' });
-    expect(result.result).toBe(212);
-  });
-});
-
-// ─── DateTime MCP ───────────────────────────────────
-describe('DateTime MCP', () => {
-  const server = createDateTimeServer();
-
-  it('dt_now returns iso string', async () => {
-    const now = server.tools!.find(t => t.name === 'dt_now')!;
-    const result = await now.handler({});
-    expect(result.iso).toBeTruthy();
-  });
-
-  it('dt_diff calculates correctly', async () => {
-    const diff = server.tools!.find(t => t.name === 'dt_diff')!;
-    const result = await diff.handler({ from: '2024-01-01', to: '2024-01-02', unit: 'days' });
-    expect(result.difference).toBe(1);
-  });
-});
-
-// ─── JSON MCP ───────────────────────────────────────
-describe('JSON MCP', () => {
-  const server = createJsonServer();
-
-  it('json_query dot-notation', async () => {
-    const query = server.tools!.find(t => t.name === 'json_query')!;
-    const result = await query.handler({ data: { users: [{ name: 'Alice' }] }, path: 'users.0.name' });
-    expect(result.results).toContain('Alice');
-  });
-
-  it('json_validate', async () => {
-    const validate = server.tools!.find(t => t.name === 'json_validate')!;
-    expect((await validate.handler({ data: '{"a":1}' })).valid).toBe(true);
-    expect((await validate.handler({ data: 'not json' })).valid).toBe(false);
-  });
-
-  it('json_diff finds differences', async () => {
-    const diff = server.tools!.find(t => t.name === 'json_diff')!;
-    const result = await diff.handler({ a: { x: 1 }, b: { x: 2 } });
-    expect(result.equal).toBe(false);
-    expect(result.differences).toHaveLength(1);
-  });
-});
-
-// ─── Regex MCP ──────────────────────────────────────
-describe('Regex MCP', () => {
-  const server = createRegexServer();
-
-  it('regex_test', async () => {
-    const test = server.tools!.find(t => t.name === 'regex_test')!;
-    expect((await test.handler({ pattern: '\\d+', text: 'abc123' })).matches).toBe(true);
-    expect((await test.handler({ pattern: '\\d+', text: 'abc' })).matches).toBe(false);
-  });
-
-  it('regex_match finds all', async () => {
-    const match = server.tools!.find(t => t.name === 'regex_match')!;
-    const result = await match.handler({ pattern: '\\d+', text: 'a1b22c333' });
-    expect(result.count).toBe(3);
-  });
-
-  it('regex_replace', async () => {
-    const replace = server.tools!.find(t => t.name === 'regex_replace')!;
-    const result = await replace.handler({ pattern: '\\d', text: 'a1b2', replacement: 'X' });
-    expect(result.result).toBe('aXbX');
-  });
-});
-
-// ─── Crypto MCP ─────────────────────────────────────
-describe('Crypto MCP', () => {
-  const server = createCryptoServer();
-
-  it('crypto_hash sha256', async () => {
-    const hash = server.tools!.find(t => t.name === 'crypto_hash')!;
-    const result = await hash.handler({ text: 'hello' });
-    expect(result.hash).toBeTruthy();
-    expect(result.algorithm).toBe('sha256');
-  });
-
-  it('crypto_random uuid', async () => {
-    const random = server.tools!.find(t => t.name === 'crypto_random')!;
-    const result = await random.handler({ type: 'uuid' });
-    expect(result.value).toMatch(/^[0-9a-f-]{36}$/);
-  });
-
-  it('crypto_encrypt + decrypt round-trip', async () => {
-    const encrypt = server.tools!.find(t => t.name === 'crypto_encrypt')!;
-    const decrypt = server.tools!.find(t => t.name === 'crypto_decrypt')!;
-    const enc = await encrypt.handler({ text: 'secret', password: 'pass123' });
-    const dec = await decrypt.handler({ encrypted: enc.encrypted, password: 'pass123', iv: enc.iv, tag: enc.tag });
-    expect(dec.decrypted).toBe('secret');
-  });
-});
-
-// ─── Chat Widget ────────────────────────────────────
-describe('Chat Widget', () => {
-  it('generates valid HTML string', () => {
-    const html = generateChatWidget({ endpoint: '/api/chat' });
-    expect(html).toContain('<!DOCTYPE html>');
-    expect(html).toContain('/api/chat');
-    expect(html).toContain('OPC Chat');
-  });
-
-  it('respects custom title and theme', () => {
-    const html = generateChatWidget({ endpoint: '/chat', theme: 'light', title: 'My Bot' });
-    expect(html).toContain('My Bot');
-    expect(html).toContain('#ffffff');
-  });
-
-  it('dark theme uses dark colors', () => {
-    const html = generateChatWidget({ endpoint: '/chat', theme: 'dark' });
-    expect(html).toContain('#1a1a2e');
-  });
-});
-
-// ─── Playground API (static check) ──────────────────
-describe('Playground page', () => {
-  it('studio-ui index.html contains playground page', () => {
-    const html = fs.readFileSync(path.join(__dirname, '../src/studio-ui/index.html'), 'utf-8');
-    expect(html).toContain('id="page-playground"');
-    expect(html).toContain('pg-model');
-    expect(html).toContain('pgSend');
-  });
-});
-
-// ─── All MCP servers have proper tool schemas ───────
-describe('MCP tool schemas', () => {
-  it('every tool has name, description, inputSchema, handler', () => {
-    const servers = listMCPServers();
-    for (const info of servers) {
-      const config = getMCPServer(info.name);
-      for (const tool of config.tools || []) {
-        expect(tool.name).toBeTruthy();
-        expect(tool.description).toBeTruthy();
-        expect(tool.inputSchema).toBeTruthy();
-        expect(typeof tool.handler).toBe('function');
-      }
-    }
-  });
-});

package/tests/mcp.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { MCPToolRegistry, createMCPTool } from '../src/tools/mcp';
-
-describe('MCP Tool System', () => {
-  it('should register and list tools', () => {
-    const registry = new MCPToolRegistry();
-    const tool = createMCPTool('calculator', 'Basic calculator', {
-      type: 'object',
-      properties: { expression: { type: 'string' } },
-    }, async (input) => ({ content: `Result: ${input.expression}` }));
-
-    registry.register(tool);
-    expect(registry.has('calculator')).toBe(true);
-    expect(registry.list().length).toBe(1);
-    expect(registry.list()[0].name).toBe('calculator');
-  });
-
-  it('should execute a tool', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('echo', 'Echo tool', {}, async (input) => ({
-      content: `Echo: ${input.text}`,
-    })));
-
-    const result = await registry.execute('echo', { text: 'hello' });
-    expect(result.content).toBe('Echo: hello');
-    expect(result.isError).toBeUndefined();
-  });
-
-  it('should return error for missing tool', async () => {
-    const registry = new MCPToolRegistry();
-    const result = await registry.execute('nonexistent', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('not found');
-  });
-
-  it('should handle tool execution errors', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('failing', 'Fails', {}, async () => {
-      throw new Error('boom');
-    }));
-
-    const result = await registry.execute('failing', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('boom');
-  });
-
-  it('should unregister tools', () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('temp', 'Temp', {}, async () => ({ content: '' })));
-    expect(registry.has('temp')).toBe(true);
-    registry.unregister('temp');
-    expect(registry.has('temp')).toBe(false);
-  });
-});

package/tests/node-network.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { NodeNetwork } from '../src/core/node-network';
-
-describe('NodeNetwork', () => {
-  let network: NodeNetwork;
-
-  beforeEach(() => { network = new NodeNetwork(); });
-
-  it('should add a node', () => {
-    const node = network.addNode({ name: 'pi-1', type: 'pi', host: '192.168.1.10' });
-    expect(node.id).toBeTruthy();
-    expect(node.name).toBe('pi-1');
-    expect(network.listNodes().length).toBe(1);
-  });
-
-  it('should remove a node', () => {
-    const node = network.addNode({ name: 'test' });
-    network.removeNode(node.id);
-    expect(network.listNodes().length).toBe(0);
-  });
-
-  it('should throw on removing unknown node', () => {
-    expect(() => network.removeNode('unknown')).toThrow('not found');
-  });
-
-  it('should get node by id', () => {
-    const node = network.addNode({ name: 'desktop-1' });
-    expect(network.getNode(node.id)?.name).toBe('desktop-1');
-    expect(network.getNode('nonexistent')).toBeNull();
-  });
-
-  it('should pair a node', async () => {
-    const node = network.addNode({ name: 'phone', type: 'phone', status: 'pairing' });
-    const result = await network.pair(node.id, 'ABC123');
-    expect(result).toBe(true);
-    expect(network.getNode(node.id)?.status).toBe('online');
-  });
-
-  it('should fail pairing with short code', async () => {
-    const node = network.addNode({ name: 'phone', status: 'pairing' });
-    const result = await network.pair(node.id, 'ab');
-    expect(result).toBe(false);
-  });
-
-  it('should send command to online node', async () => {
-    const node = network.addNode({ name: 'vps', status: 'online' });
-    const result = await network.sendCommand(node.id, 'uptime');
-    expect(result.command).toBe('uptime');
-    expect(result.status).toBe('sent');
-  });
-
-  it('should throw sending to offline node', async () => {
-    const node = network.addNode({ name: 'offline', status: 'offline' });
-    await expect(network.sendCommand(node.id, 'test')).rejects.toThrow('offline');
-  });
-
-  it('should broadcast to online nodes', async () => {
-    network.addNode({ name: 'n1', status: 'online' });
-    network.addNode({ name: 'n2', status: 'online' });
-    network.addNode({ name: 'n3', status: 'offline' });
-    const results = await network.broadcast('ping');
-    expect(results.size).toBe(2);
-  });
-
-  it('should health check all nodes', async () => {
-    network.addNode({ name: 'up', status: 'online' });
-    network.addNode({ name: 'down', status: 'offline' });
-    const health = await network.healthCheck();
-    expect(health.size).toBe(2);
-    const vals = Array.from(health.values());
-    expect(vals).toContain(true);
-    expect(vals).toContain(false);
-  });
-});