agent-relay 2.0.28 → 2.0.32

package/packages/sdk/src/client.test.ts

@@ -0,0 +1,568 @@
+import { describe, it, expect, vi } from 'vitest';
+import type {
+  Envelope,
+  ErrorPayload,
+  WelcomePayload,
+  DeliverEnvelope,
+  AckPayload,
+  StatusResponsePayload,
+  ListAgentsResponsePayload,
+  HealthResponsePayload,
+  MetricsResponsePayload,
+  InboxResponsePayload,
+} from '@agent-relay/protocol';
+import { RelayClient } from './client.js';
+
+describe('RelayClient', () => {
+  describe('configuration', () => {
+    it('should use default config values', () => {
+      const client = new RelayClient({});
+      expect(client.state).toBe('DISCONNECTED');
+    });
+
+    it('should accept custom config', () => {
+      const client = new RelayClient({
+        agentName: 'TestAgent',
+        socketPath: '/custom/socket.sock',
+        reconnect: false,
+        maxReconnectAttempts: 5,
+      });
+      expect(client.state).toBe('DISCONNECTED');
+    });
+
+    it('should use agentName from config', () => {
+      const client = new RelayClient({ agentName: 'CustomAgent' });
+      // agentName is stored internally
+      expect((client as any).config.agentName).toBe('CustomAgent');
+    });
+  });
+
+  describe('state management', () => {
+    it('should start in DISCONNECTED state', () => {
+      const client = new RelayClient({});
+      expect(client.state).toBe('DISCONNECTED');
+    });
+
+    it('should notify on state change', () => {
+      const client = new RelayClient({ reconnect: false });
+      const states: string[] = [];
+      client.onStateChange = (state) => states.push(state);
+
+      // Trigger internal state changes using setState
+      (client as any).setState('CONNECTING');
+      (client as any).setState('READY');
+
+      expect(states).toContain('CONNECTING');
+      expect(states).toContain('READY');
+    });
+  });
+
+  describe('message handling', () => {
+    it('should call onMessage when DELIVER received', () => {
+      const client = new RelayClient({ reconnect: false });
+      const messages: any[] = [];
+      client.onMessage = (from, payload, id, meta, originalTo) => messages.push({ from, payload, id, originalTo });
+
+      // DELIVER envelope has delivery info and from at envelope level
+      const deliverEnvelope: DeliverEnvelope = {
+        v: 1,
+        type: 'DELIVER',
+        id: 'msg-1',
+        ts: Date.now(),
+        from: 'Alice',
+        payload: {
+          kind: 'message',
+          body: 'Hello!',
+        },
+        delivery: {
+          seq: 1,
+          session_id: 'session-1',
+        },
+      };
+
+      (client as any).processFrame(deliverEnvelope);
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0].from).toBe('Alice');
+      expect(messages[0].payload.body).toBe('Hello!');
+      expect(messages[0].originalTo).toBeUndefined();
+    });
+
+    it('should pass originalTo for broadcast messages', () => {
+      const client = new RelayClient({ reconnect: false });
+      const messages: any[] = [];
+      client.onMessage = (from, payload, id, meta, originalTo) => messages.push({ from, payload, id, originalTo });
+
+      // DELIVER envelope for a broadcast message includes originalTo: '*'
+      const deliverEnvelope: DeliverEnvelope = {
+        v: 1,
+        type: 'DELIVER',
+        id: 'msg-2',
+        ts: Date.now(),
+        from: 'Dashboard',
+        to: 'Bob',
+        payload: {
+          kind: 'message',
+          body: 'Hello everyone!',
+        },
+        delivery: {
+          seq: 1,
+          session_id: 'session-1',
+          originalTo: '*', // This was a broadcast
+        },
+      };
+
+      (client as any).processFrame(deliverEnvelope);
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0].from).toBe('Dashboard');
+      expect(messages[0].payload.body).toBe('Hello everyone!');
+      expect(messages[0].originalTo).toBe('*');
+    });
+
+    it('should handle WELCOME and transition to READY', () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'CONNECTING';
+
+      const welcomeEnvelope: Envelope<WelcomePayload> = {
+        v: 1,
+        type: 'WELCOME',
+        id: 'welcome-1',
+        ts: Date.now(),
+        payload: {
+          session_id: 'session-123',
+          server: {
+            max_frame_bytes: 1024 * 1024,
+            heartbeat_ms: 5000,
+          },
+        },
+      };
+
+      (client as any).processFrame(welcomeEnvelope);
+
+      expect(client.state).toBe('READY');
+    });
+  });
+
+  describe('error handling', () => {
+    it('clears resume token after RESUME_TOO_OLD error', () => {
+      const client = new RelayClient({ reconnect: false });
+
+      // Simulate a stored resume token that the server rejects
+      (client as any).resumeToken = 'stale-token';
+
+      const errorEnvelope: Envelope<ErrorPayload> = {
+        v: 1,
+        type: 'ERROR',
+        id: 'err-1',
+        ts: Date.now(),
+        payload: {
+          code: 'RESUME_TOO_OLD',
+          message: 'Session resume not yet supported; starting new session',
+          fatal: false,
+        },
+      };
+
+      (client as any).processFrame(errorEnvelope);
+
+      expect((client as any).resumeToken).toBeUndefined();
+    });
+
+    it('should handle ERROR frames without crashing', () => {
+      const client = new RelayClient({ reconnect: false });
+
+      const errorEnvelope: Envelope<ErrorPayload> = {
+        v: 1,
+        type: 'ERROR',
+        id: 'err-1',
+        ts: Date.now(),
+        payload: {
+          code: 'INTERNAL_ERROR' as any,
+          message: 'Something went wrong',
+          fatal: true,
+        },
+      };
+
+      // Should not throw
+      expect(() => (client as any).processFrame(errorEnvelope)).not.toThrow();
+    });
+  });
+
+  describe('sendMessage', () => {
+    it('should return false when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.sendMessage('Alice', 'Hello');
+      expect(result).toBe(false);
+    });
+
+    it('should return false when in wrong state', () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'CONNECTING';
+      const result = client.sendMessage('Alice', 'Hello');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('sendAndWait', () => {
+    it('resolves when matching ACK arrives', async () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.sendAndWait('Bob', 'ping', { timeoutMs: 1000 });
+      const sentEnvelope = sendMock.mock.calls[0][0];
+      const correlationId = sentEnvelope.payload_meta.sync.correlationId;
+
+      const ackEnvelope: Envelope<AckPayload> = {
+        v: 1,
+        type: 'ACK',
+        id: 'ack-1',
+        ts: Date.now(),
+        payload: {
+          ack_id: 'd-1',
+          seq: 1,
+          correlationId,
+          response: 'OK',
+        },
+      };
+
+      (client as any).processFrame(ackEnvelope);
+
+      await expect(promise).resolves.toMatchObject({ correlationId, response: 'OK' });
+    });
+
+    it('rejects on timeout', async () => {
+      vi.useFakeTimers();
+      try {
+        const client = new RelayClient({ reconnect: false });
+        (client as any)._state = 'READY';
+        const sendMock = vi.fn().mockReturnValue(true);
+        (client as any).send = sendMock;
+
+        const promise = client.sendAndWait('Bob', 'ping', { timeoutMs: 50 });
+        const rejection = expect(promise).rejects.toThrow('ACK timeout');
+        await vi.advanceTimersByTimeAsync(60);
+
+        await rejection;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('rejects when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.sendAndWait('Bob', 'ping')).rejects.toThrow('Client not ready');
+    });
+  });
+
+  describe('channel operations', () => {
+    it('should return false for joinChannel when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.joinChannel('#general');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for leaveChannel when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.leaveChannel('#general');
+      expect(result).toBe(false);
+    });
+
+    it('should return false for sendChannelMessage when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.sendChannelMessage('#general', 'Hello');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('disconnect', () => {
+    it('should transition to DISCONNECTED state', () => {
+      const client = new RelayClient({ reconnect: false });
+      (client as any)._state = 'READY';
+
+      client.disconnect();
+
+      expect(client.state).toBe('DISCONNECTED');
+    });
+  });
+
+  describe('query operations', () => {
+    it('should reject getStatus when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.getStatus()).rejects.toThrow('Client not ready');
+    });
+
+    it('should reject listAgents when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.listAgents()).rejects.toThrow('Client not ready');
+    });
+
+    it('should reject getHealth when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.getHealth()).rejects.toThrow('Client not ready');
+    });
+
+    it('should reject getMetrics when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.getMetrics()).rejects.toThrow('Client not ready');
+    });
+
+    it('should reject getInbox when not ready', async () => {
+      const client = new RelayClient({ reconnect: false });
+      await expect(client.getInbox()).rejects.toThrow('Client not ready');
+    });
+
+    it('resolves getStatus when STATUS_RESPONSE arrives', async () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.getStatus();
+      const sentEnvelope = sendMock.mock.calls[0][0];
+
+      const responseEnvelope: Envelope<StatusResponsePayload> = {
+        v: 1,
+        type: 'STATUS_RESPONSE',
+        id: sentEnvelope.id,
+        ts: Date.now(),
+        payload: {
+          version: '2.0.0',
+          uptime: 12345,
+          agentCount: 5,
+        },
+      };
+
+      (client as any).processFrame(responseEnvelope);
+
+      const result = await promise;
+      expect(result.version).toBe('2.0.0');
+      expect(result.uptime).toBe(12345);
+      expect(result.agentCount).toBe(5);
+    });
+
+    it('resolves listAgents when LIST_AGENTS_RESPONSE arrives', async () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.listAgents({ includeIdle: false });
+      const sentEnvelope = sendMock.mock.calls[0][0];
+
+      const responseEnvelope: Envelope<ListAgentsResponsePayload> = {
+        v: 1,
+        type: 'LIST_AGENTS_RESPONSE',
+        id: sentEnvelope.id,
+        ts: Date.now(),
+        payload: {
+          agents: [
+            { name: 'Alice', cli: 'claude', idle: false },
+            { name: 'Bob', cli: 'codex', idle: true },
+          ],
+        },
+      };
+
+      (client as any).processFrame(responseEnvelope);
+
+      const result = await promise;
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('Alice');
+      expect(result[1].name).toBe('Bob');
+    });
+
+    it('resolves getHealth when HEALTH_RESPONSE arrives', async () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.getHealth();
+      const sentEnvelope = sendMock.mock.calls[0][0];
+
+      const responseEnvelope: Envelope<HealthResponsePayload> = {
+        v: 1,
+        type: 'HEALTH_RESPONSE',
+        id: sentEnvelope.id,
+        ts: Date.now(),
+        payload: {
+          healthScore: 95,
+          summary: 'System healthy',
+          issues: [],
+          recommendations: [],
+          crashes: [],
+          alerts: [],
+          stats: { totalCrashes24h: 0, totalAlerts24h: 0, agentCount: 3 },
+        },
+      };
+
+      (client as any).processFrame(responseEnvelope);
+
+      const result = await promise;
+      expect(result.healthScore).toBe(95);
+      expect(result.summary).toBe('System healthy');
+    });
+
+    it('resolves getMetrics when METRICS_RESPONSE arrives', async () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.getMetrics();
+      const sentEnvelope = sendMock.mock.calls[0][0];
+
+      const responseEnvelope: Envelope<MetricsResponsePayload> = {
+        v: 1,
+        type: 'METRICS_RESPONSE',
+        id: sentEnvelope.id,
+        ts: Date.now(),
+        payload: {
+          agents: [
+            { name: 'Alice', status: 'active', rssBytes: 100000, cpuPercent: 5.2 },
+          ],
+          system: { totalMemory: 16000000, freeMemory: 8000000, heapUsed: 50000 },
+        },
+      };
+
+      (client as any).processFrame(responseEnvelope);
+
+      const result = await promise;
+      expect(result.agents).toHaveLength(1);
+      expect(result.agents[0].name).toBe('Alice');
+      expect(result.system.heapUsed).toBe(50000);
+    });
+
+    it('resolves getInbox when INBOX_RESPONSE arrives', async () => {
+      const client = new RelayClient({ reconnect: false, quiet: true, agentName: 'TestAgent' });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const promise = client.getInbox({ limit: 10 });
+      const sentEnvelope = sendMock.mock.calls[0][0];
+
+      const responseEnvelope: Envelope<InboxResponsePayload> = {
+        v: 1,
+        type: 'INBOX_RESPONSE',
+        id: sentEnvelope.id,
+        ts: Date.now(),
+        payload: {
+          messages: [
+            { id: 'msg-1', from: 'Alice', body: 'Hello!', timestamp: Date.now() },
+          ],
+        },
+      };
+
+      (client as any).processFrame(responseEnvelope);
+
+      const result = await promise;
+      expect(result).toHaveLength(1);
+      expect(result[0].from).toBe('Alice');
+      expect(result[0].body).toBe('Hello!');
+    });
+
+    it('query times out if no response arrives', async () => {
+      vi.useFakeTimers();
+      try {
+        const client = new RelayClient({ reconnect: false, quiet: true });
+        (client as any)._state = 'READY';
+        const sendMock = vi.fn().mockReturnValue(true);
+        (client as any).send = sendMock;
+
+        const promise = client.getStatus();
+        const rejection = expect(promise).rejects.toThrow('Query timeout');
+        await vi.advanceTimersByTimeAsync(6000);
+
+        await rejection;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+  });
+
+  describe('consensus operations', () => {
+    it('should return false for createProposal when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.createProposal({
+        title: 'Test',
+        description: 'Test proposal',
+        participants: ['Alice', 'Bob'],
+      });
+      expect(result).toBe(false);
+    });
+
+    it('should return false for vote when not connected', () => {
+      const client = new RelayClient({ reconnect: false });
+      const result = client.vote({
+        proposalId: 'prop_123',
+        value: 'approve',
+      });
+      expect(result).toBe(false);
+    });
+
+    it('should send PROPOSE command to _consensus', () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const result = client.createProposal({
+        title: 'Approve design',
+        description: 'Should we proceed?',
+        participants: ['Alice', 'Bob', 'Charlie'],
+        consensusType: 'supermajority',
+        threshold: 0.75,
+      });
+
+      expect(result).toBe(true);
+      expect(sendMock).toHaveBeenCalled();
+
+      const envelope = sendMock.mock.calls[0][0];
+      expect(envelope.type).toBe('SEND');
+      expect(envelope.to).toBe('_consensus');
+      expect(envelope.payload.body).toContain('PROPOSE: Approve design');
+      expect(envelope.payload.body).toContain('TYPE: supermajority');
+      expect(envelope.payload.body).toContain('PARTICIPANTS: Alice, Bob, Charlie');
+      expect(envelope.payload.body).toContain('DESCRIPTION: Should we proceed?');
+      expect(envelope.payload.body).toContain('THRESHOLD: 0.75');
+    });
+
+    it('should send VOTE command to _consensus', () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      const result = client.vote({
+        proposalId: 'prop_123_abc',
+        value: 'approve',
+        reason: 'LGTM',
+      });
+
+      expect(result).toBe(true);
+      expect(sendMock).toHaveBeenCalled();
+
+      const envelope = sendMock.mock.calls[0][0];
+      expect(envelope.type).toBe('SEND');
+      expect(envelope.to).toBe('_consensus');
+      expect(envelope.payload.body).toBe('VOTE prop_123_abc approve LGTM');
+    });
+
+    it('should send VOTE without reason', () => {
+      const client = new RelayClient({ reconnect: false, quiet: true });
+      (client as any)._state = 'READY';
+      const sendMock = vi.fn().mockReturnValue(true);
+      (client as any).send = sendMock;
+
+      client.vote({
+        proposalId: 'prop_456',
+        value: 'reject',
+      });
+
+      const envelope = sendMock.mock.calls[0][0];
+      expect(envelope.payload.body).toBe('VOTE prop_456 reject');
+    });
+  });
+});