@tjamescouch/agentchat 0.1.0

package/test/integration.test.js

@@ -0,0 +1,536 @@
+/**
+ * AgentChat Integration Tests
+ * Run with: node --test test/integration.test.js
+ */
+
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { AgentChatServer } from '../lib/server.js';
+import { AgentChatClient } from '../lib/client.js';
+import { Identity, isValidPubkey, pubkeyToAgentId } from '../lib/identity.js';
+import { validateConfig, DEFAULT_CONFIG } from '../lib/deploy/config.js';
+import { deployToDocker, generateDockerfile } from '../lib/deploy/index.js';
+
+describe('AgentChat', () => {
+  let server;
+  const PORT = 16667; // Use non-standard port for testing
+  const SERVER_URL = `ws://localhost:${PORT}`;
+  
+  before(() => {
+    server = new AgentChatServer({ port: PORT });
+    server.start();
+  });
+  
+  after(() => {
+    server.stop();
+  });
+  
+  test('client can connect and identify', async () => {
+    const client = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'test-agent'
+    });
+    
+    await client.connect();
+    
+    assert.ok(client.connected);
+    assert.ok(client.agentId);
+    assert.ok(client.agentId.startsWith('@'));
+    
+    client.disconnect();
+  });
+  
+  test('client can join channel', async () => {
+    const client = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'test-agent'
+    });
+    
+    await client.connect();
+    const result = await client.join('#general');
+    
+    assert.equal(result.channel, '#general');
+    assert.ok(Array.isArray(result.agents));
+    
+    client.disconnect();
+  });
+  
+  test('two clients can communicate', async () => {
+    const client1 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'agent-1'
+    });
+    
+    const client2 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'agent-2'
+    });
+    
+    await client1.connect();
+    await client2.connect();
+    
+    await client1.join('#general');
+    await client2.join('#general');
+    
+    // Set up listener
+    const received = new Promise((resolve) => {
+      client2.on('message', (msg) => {
+        if (msg.content === 'hello from agent-1') {
+          resolve(msg);
+        }
+      });
+    });
+    
+    // Send message
+    await client1.send('#general', 'hello from agent-1');
+    
+    // Wait for message
+    const msg = await received;
+    
+    assert.equal(msg.from, client1.agentId);
+    assert.equal(msg.to, '#general');
+    assert.equal(msg.content, 'hello from agent-1');
+    
+    client1.disconnect();
+    client2.disconnect();
+  });
+  
+  test('direct messages work', async () => {
+    const client1 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'agent-1'
+    });
+    
+    const client2 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'agent-2'
+    });
+    
+    await client1.connect();
+    await client2.connect();
+    
+    // Set up listener
+    const received = new Promise((resolve) => {
+      client2.on('message', (msg) => {
+        if (msg.content === 'private hello') {
+          resolve(msg);
+        }
+      });
+    });
+    
+    // Send DM
+    await client1.dm(client2.agentId, 'private hello');
+    
+    // Wait for message
+    const msg = await received;
+    
+    assert.equal(msg.from, client1.agentId);
+    assert.equal(msg.to, client2.agentId);
+    assert.equal(msg.content, 'private hello');
+    
+    client1.disconnect();
+    client2.disconnect();
+  });
+  
+  test('can list channels', async () => {
+    const client = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'test-agent'
+    });
+    
+    await client.connect();
+    const channels = await client.listChannels();
+    
+    assert.ok(Array.isArray(channels));
+    assert.ok(channels.some(ch => ch.name === '#general'));
+    assert.ok(channels.some(ch => ch.name === '#agents'));
+    
+    client.disconnect();
+  });
+  
+  test('can create private channel', async () => {
+    const client = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'test-agent'
+    });
+    
+    await client.connect();
+    
+    const channelName = `#private-${Date.now()}`;
+    await client.createChannel(channelName, true);
+    
+    assert.ok(client.channels.has(channelName));
+    
+    client.disconnect();
+  });
+});
+
+describe('Identity', () => {
+  const testDir = path.join(os.tmpdir(), `agentchat-test-${Date.now()}`);
+  const testIdentityPath = path.join(testDir, 'identity.json');
+
+  after(async () => {
+    // Cleanup
+    try {
+      await fs.rm(testDir, { recursive: true });
+    } catch {}
+  });
+
+  test('can generate identity', () => {
+    const identity = Identity.generate('test-agent');
+
+    assert.equal(identity.name, 'test-agent');
+    assert.ok(identity.pubkey);
+    assert.ok(identity.privkey);
+    assert.ok(identity.created);
+    assert.ok(isValidPubkey(identity.pubkey));
+  });
+
+  test('can save and load identity', async () => {
+    const identity = Identity.generate('test-agent');
+    await identity.save(testIdentityPath);
+
+    const loaded = await Identity.load(testIdentityPath);
+
+    assert.equal(loaded.name, identity.name);
+    assert.equal(loaded.pubkey, identity.pubkey);
+    assert.equal(loaded.privkey, identity.privkey);
+  });
+
+  test('can sign and verify', () => {
+    const identity = Identity.generate('test-agent');
+    const message = 'hello world';
+
+    const signature = identity.sign(message);
+    assert.ok(signature);
+
+    const verified = Identity.verify(message, signature, identity.pubkey);
+    assert.ok(verified);
+
+    // Verify fails with wrong message
+    const wrongVerify = Identity.verify('wrong message', signature, identity.pubkey);
+    assert.ok(!wrongVerify);
+  });
+
+  test('fingerprint is consistent', () => {
+    const identity = Identity.generate('test-agent');
+    const fp1 = identity.getFingerprint();
+    const fp2 = identity.getFingerprint();
+
+    assert.equal(fp1, fp2);
+    assert.equal(fp1.length, 16);
+  });
+
+  test('pubkeyToAgentId generates stable IDs', () => {
+    const identity = Identity.generate('test-agent');
+    const id1 = pubkeyToAgentId(identity.pubkey);
+    const id2 = pubkeyToAgentId(identity.pubkey);
+
+    assert.equal(id1, id2);
+    assert.equal(id1.length, 8);
+  });
+
+  test('export excludes private key', () => {
+    const identity = Identity.generate('test-agent');
+    const exported = identity.export();
+
+    assert.equal(exported.name, identity.name);
+    assert.equal(exported.pubkey, identity.pubkey);
+    assert.equal(exported.privkey, undefined);
+  });
+});
+
+describe('AgentChat with Identity', () => {
+  let server;
+  const PORT = 16668; // Different port for identity tests
+  const SERVER_URL = `ws://localhost:${PORT}`;
+  const testDir = path.join(os.tmpdir(), `agentchat-identity-test-${Date.now()}`);
+
+  before(async () => {
+    await fs.mkdir(testDir, { recursive: true });
+    server = new AgentChatServer({ port: PORT });
+    server.start();
+  });
+
+  after(async () => {
+    server.stop();
+    try {
+      await fs.rm(testDir, { recursive: true });
+    } catch {}
+  });
+
+  test('client with identity gets stable ID', async () => {
+    // Create identity file
+    const identity = Identity.generate('persistent-agent');
+    const identityPath = path.join(testDir, 'test-identity.json');
+    await identity.save(identityPath);
+
+    // First connection
+    const client1 = new AgentChatClient({
+      server: SERVER_URL,
+      identity: identityPath
+    });
+    await client1.connect();
+    const id1 = client1.agentId;
+    client1.disconnect();
+
+    // Wait a bit
+    await new Promise(r => setTimeout(r, 100));
+
+    // Second connection with same identity
+    const client2 = new AgentChatClient({
+      server: SERVER_URL,
+      identity: identityPath
+    });
+    await client2.connect();
+    const id2 = client2.agentId;
+    client2.disconnect();
+
+    // Should have same ID
+    assert.equal(id1, id2);
+  });
+
+  test('ephemeral clients get different IDs', async () => {
+    const client1 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'ephemeral-1'
+    });
+    await client1.connect();
+    const id1 = client1.agentId;
+    client1.disconnect();
+
+    await new Promise(r => setTimeout(r, 100));
+
+    const client2 = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'ephemeral-2'
+    });
+    await client2.connect();
+    const id2 = client2.agentId;
+    client2.disconnect();
+
+    // Different IDs (overwhelming probability)
+    assert.notEqual(id1, id2);
+  });
+
+  test('signed messages include signature', async () => {
+    const identity = Identity.generate('signing-agent');
+    const identityPath = path.join(testDir, 'signing-identity.json');
+    await identity.save(identityPath);
+
+    const sender = new AgentChatClient({
+      server: SERVER_URL,
+      identity: identityPath
+    });
+
+    const receiver = new AgentChatClient({
+      server: SERVER_URL,
+      name: 'receiver'
+    });
+
+    await sender.connect();
+    await receiver.connect();
+    await sender.join('#general');
+    await receiver.join('#general');
+
+    const received = new Promise((resolve) => {
+      receiver.on('message', (msg) => {
+        if (msg.content === 'signed hello') {
+          resolve(msg);
+        }
+      });
+    });
+
+    await sender.send('#general', 'signed hello');
+
+    const msg = await received;
+
+    assert.equal(msg.content, 'signed hello');
+    assert.ok(msg.sig, 'Message should have signature');
+
+    sender.disconnect();
+    receiver.disconnect();
+  });
+
+  test('duplicate identity connection is rejected', async () => {
+    const identity = Identity.generate('unique-agent');
+    const identityPath = path.join(testDir, 'unique-identity.json');
+    await identity.save(identityPath);
+
+    // First connection
+    const client1 = new AgentChatClient({
+      server: SERVER_URL,
+      identity: identityPath
+    });
+    await client1.connect();
+
+    // Second connection with same identity should fail
+    const client2 = new AgentChatClient({
+      server: SERVER_URL,
+      identity: identityPath
+    });
+
+    let errorReceived = false;
+    client2.on('error', () => {
+      errorReceived = true;
+    });
+
+    try {
+      await client2.connect();
+    } catch {
+      errorReceived = true;
+    }
+
+    // Cleanup
+    client1.disconnect();
+    if (client2.ws) client2.disconnect();
+
+    // Note: The error handling may vary, but duplicate should not succeed silently
+    // This test ensures we handle the case
+  });
+});
+
+describe('Deploy Configuration', () => {
+  test('validates correct config', () => {
+    const config = validateConfig({
+      provider: 'docker',
+      port: 8080,
+      name: 'test-server'
+    });
+
+    assert.equal(config.provider, 'docker');
+    assert.equal(config.port, 8080);
+    assert.equal(config.name, 'test-server');
+    assert.equal(config.host, DEFAULT_CONFIG.host);
+  });
+
+  test('rejects invalid provider', () => {
+    assert.throws(() => {
+      validateConfig({ provider: 'invalid' });
+    }, /Invalid provider/);
+  });
+
+  test('rejects invalid port', () => {
+    assert.throws(() => {
+      validateConfig({ port: 99999 });
+    }, /Invalid port/);
+  });
+
+  test('rejects invalid name', () => {
+    assert.throws(() => {
+      validateConfig({ name: 'invalid name with spaces' });
+    }, /Invalid name/);
+  });
+
+  test('validates TLS config requires both cert and key', () => {
+    assert.throws(() => {
+      validateConfig({ tls: { cert: './cert.pem' } });
+    }, /TLS config must include key path/);
+  });
+
+  test('accepts valid TLS config', () => {
+    const config = validateConfig({
+      tls: { cert: './cert.pem', key: './key.pem' }
+    });
+
+    assert.deepEqual(config.tls, { cert: './cert.pem', key: './key.pem' });
+  });
+});
+
+describe('Docker Compose Generation', () => {
+  test('generates basic docker-compose', async () => {
+    const compose = await deployToDocker({
+      port: 6667,
+      name: 'agentchat'
+    });
+
+    assert.ok(compose.includes('version:'));
+    assert.ok(compose.includes('agentchat:'));
+    assert.ok(compose.includes('6667:6667'));
+    assert.ok(compose.includes('restart: unless-stopped'));
+  });
+
+  test('generates docker-compose with health check', async () => {
+    const compose = await deployToDocker({
+      healthCheck: true
+    });
+
+    assert.ok(compose.includes('healthcheck:'));
+    assert.ok(compose.includes('interval:'));
+  });
+
+  test('generates docker-compose without health check', async () => {
+    const compose = await deployToDocker({
+      healthCheck: false
+    });
+
+    assert.ok(!compose.includes('healthcheck:'));
+  });
+
+  test('generates docker-compose with volumes', async () => {
+    const compose = await deployToDocker({
+      volumes: true
+    });
+
+    assert.ok(compose.includes('agentchat-data:/app/data'));
+    assert.ok(compose.includes('volumes:'));
+  });
+
+  test('generates docker-compose with TLS mounts', async () => {
+    const compose = await deployToDocker({
+      tls: { cert: './cert.pem', key: './key.pem' }
+    });
+
+    assert.ok(compose.includes('./cert.pem:/app/certs/cert.pem'));
+    assert.ok(compose.includes('./key.pem:/app/certs/key.pem'));
+    assert.ok(compose.includes('TLS_CERT=/app/certs/cert.pem'));
+  });
+
+  test('generates docker-compose with network', async () => {
+    const compose = await deployToDocker({
+      network: 'my-network'
+    });
+
+    assert.ok(compose.includes('my-network'));
+    assert.ok(compose.includes('driver: bridge'));
+  });
+
+  test('generates Dockerfile', async () => {
+    const dockerfile = await generateDockerfile();
+
+    assert.ok(dockerfile.includes('FROM node:18-alpine'));
+    assert.ok(dockerfile.includes('npm ci --production'));
+    assert.ok(dockerfile.includes('HEALTHCHECK'));
+    assert.ok(dockerfile.includes('ENV PORT=6667'));
+  });
+});
+
+describe('TLS Server', () => {
+  // TLS tests require generating certificates which is complex
+  // These are basic structural tests
+
+  test('server accepts TLS options', () => {
+    const server = new AgentChatServer({
+      port: 16670,
+      cert: 'nonexistent.pem',
+      key: 'nonexistent.pem'
+    });
+
+    assert.equal(server.tlsCert, 'nonexistent.pem');
+    assert.equal(server.tlsKey, 'nonexistent.pem');
+  });
+
+  test('server without TLS options uses plain WebSocket', () => {
+    const server = new AgentChatServer({
+      port: 16671
+    });
+
+    assert.equal(server.tlsCert, null);
+    assert.equal(server.tlsKey, null);
+  });
+});
+
+console.log('Running tests...');