Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

4.5 KB
Raw Blame
/**
 * The relay's payloads come from the peer, and on a password-free install an
 * announced peer is any LAN host. socket.io-client runs listeners in a
 * nextTick, so a listener that throws becomes an uncaughtException and the
 * server exits — then crash-loops, since every boot reconnects to the peer.
 *
 * Drives a REAL Socket.IO server playing the hostile peer and the REAL relay
 * client over loopback; vitest fails the run on any uncaught error.
 */
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createServer } from 'http';
import { Server } from 'socket.io';

vi.mock('./instanceIdentity.js', () => ({
  getInstanceId: async () => 'self-example-instance',
  UNKNOWN_INSTANCE_ID: 'unknown',
}));

const { connectToPeer, disconnectFromPeer } = await import('./peerSocketRelay.js');
const { instanceEvents } = await import('./instanceEvents.js');

const PEER = { id: 'peer-example', name: 'Example Peer', address: '127.0.0.1' };
const MALFORMED = [null, undefined, 'agent', 42, [], { agent: null }, {}, { id: '' }, { agent: { id: 7 } }];

let httpServer;
let ioServer;

const startHostilePeer = (onSubscribe) => new Promise((resolve) => {
  httpServer = createServer((req, res) => {
    // fetchPeerAgents' initial snapshot, equally peer-controlled.
    res.setHeader('Content-Type', 'application/json');
    res.end(JSON.stringify({ running: [null, 'agent', { id: 'agent-listed' }, { id: '' }] }));
  });
  ioServer = new Server(httpServer);
  ioServer.on('connection', (socket) => socket.on('cos:subscribe', () => onSubscribe(socket)));
  httpServer.listen(0, '127.0.0.1', () => resolve(httpServer.address().port));
});

const record = () => {
  const seen = [];
  const events = ['peer:agent:spawned', 'peer:agent:updated', 'peer:agent:completed', 'peer:agent:output', 'peer:agents:updated'];
  const listeners = events.map((event) => {
    const listener = (payload) => seen.push([event, payload]);
    instanceEvents.on(event, listener);
    return [event, listener];
  });
  return { seen, stop: () => listeners.forEach(([event, listener]) => instanceEvents.off(event, listener)) };
};

afterEach(async () => {
  disconnectFromPeer(PEER.id);
  if (ioServer) await new Promise((resolve) => ioServer.close(resolve));
  ioServer = undefined;
  httpServer = undefined;
});

describe('peer socket relay with hostile payloads', () => {
  it('drops malformed agent events without throwing and still relays well-formed ones', async () => {
    const recorder = record();
    const done = new Promise((resolve) => instanceEvents.on('peer:agent:completed', function onDone({ agent }) {
      if (agent?.id !== 'agent-valid') return;
      instanceEvents.off('peer:agent:completed', onDone);
      resolve();
    }));
    const port = await startHostilePeer((socket) => {
      for (const payload of MALFORMED) {
        socket.emit('cos:agent:spawned', payload);
        socket.emit('cos:agent:updated', payload);
        socket.emit('cos:agent:completed', payload);
        socket.emit('cos:agent:output', payload);
      }
      socket.emit('cos:agent:output', { peerId: 'peer-spoofed', agentId: 'agent-valid', line: 'example' });
      socket.emit('cos:agent:spawned', { agent: { id: 'agent-valid', status: 'running' } });
      socket.emit('cos:agent:updated', { id: 'agent-valid', status: 'reviewing' });
      socket.emit('cos:agent:completed', { agent: { id: 'agent-valid' } });
    });

    connectToPeer({ ...PEER, port });
    await done;
    recorder.stop();

    const agentEvents = recorder.seen.filter(([event]) => ['peer:agent:spawned', 'peer:agent:updated', 'peer:agent:completed'].includes(event));
    expect(agentEvents.map(([event, { agent }]) => [event, agent.id, agent.status])).toEqual([
      ['peer:agent:spawned', 'agent-valid', 'running'],
      ['peer:agent:updated', 'agent-valid', 'reviewing'],
      ['peer:agent:completed', 'agent-valid', undefined],
    ]);
    // Output frames are opaque; only a non-object is dropped, and the peer
    // cannot attribute its output to another peer.
    const outputs = recorder.seen.filter(([event]) => event === 'peer:agent:output').map(([, payload]) => payload);
    expect(outputs.every((payload) => payload.peerId === PEER.id)).toBe(true);
    expect(outputs).toContainEqual({ peerId: PEER.id, agentId: 'agent-valid', line: 'example' });
    const snapshotAgents = recorder.seen.filter(([event]) => event === 'peer:agents:updated').flatMap(([, { agents }]) => agents);
    expect(snapshotAgents.every((agent) => typeof agent?.id === 'string' && agent.id)).toBe(true);
  });
});