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

fix(security): stop a peer's malformed relay events from crashing the server

Adam Eivyc6805f157eb6
diff --git a/server/services/peerSocketRelay.js b/server/services/peerSocketRelay.js
index 1f4c42e89b..771940b9bd 100644
--- a/server/services/peerSocketRelay.js
+++ b/server/services/peerSocketRelay.js
@@ -10,12 +10,20 @@ import { instanceEvents } from './instanceEvents.js';
import { peerBaseUrl } from '../lib/peerUrl.js';
import { peerFetch, peerSocketOptionsFor } from '../lib/peerHttpClient.js';
import { withAbortTimeout } from '../lib/abortTimeout.js';
+import { isPlainObject } from '../lib/objects.js';
// Map<peerId, { socket, agents: Map<agentId, agent>, peer }>
const peerConnections = new Map();
const CONNECT_TIMEOUT_MS = 5000;
+// Relay payloads are peer-controlled — on a password-free install an announced
+// peer is any LAN host — so only a plain object with a string id is an agent.
+const relayedAgent = (data) => {
+ const agent = isPlainObject(data?.agent) ? data.agent : data;
+ return isPlainObject(agent) && typeof agent.id === 'string' && agent.id ? agent : null;
+};
+
/**
* Connect to a peer's Socket.IO server and subscribe to agent events
*/
@@ -61,9 +69,20 @@ export function connectToPeer(peer) {
instanceEvents.emit('peer:agents:updated', { peerId: peer.id, agents: [] });
});
+ // socket.io-client calls listeners from a nextTick, where a throw is an
+ // uncaughtException that exits the server; contain it per event.
+ const onPeerAgentEvent = (event, handler) => socket.on(event, (data) => {
+ try {
+ handler(data);
+ } catch (err) {
+ console.error(`❌ Peer relay ${event} from ${peer.name} failed: ${err.message}`);
+ }
+ });
+
// Agent spawned
- socket.on('cos:agent:spawned', (data) => {
- const agent = data.agent || data;
+ onPeerAgentEvent('cos:agent:spawned', (data) => {
+ const agent = relayedAgent(data);
+ if (!agent) return;
conn.agents.set(agent.id, agent);
instanceEvents.emit('peer:agent:spawned', { peerId: peer.id, agent });
instanceEvents.emit('peer:agents:updated', {
@@ -73,25 +92,25 @@ export function connectToPeer(peer) {
});
// Agent updated
- socket.on('cos:agent:updated', (data) => {
- const agent = data.agent || data;
- const existing = conn.agents.get(agent.id);
- if (existing) {
- Object.assign(existing, agent);
- } else {
- conn.agents.set(agent.id, agent);
- }
- instanceEvents.emit('peer:agent:updated', { peerId: peer.id, agent: conn.agents.get(agent.id) });
+ onPeerAgentEvent('cos:agent:updated', (data) => {
+ const agent = relayedAgent(data);
+ if (!agent) return;
+ // Spread, not Object.assign: a peer-sent `__proto__` key stays plain data.
+ const merged = { ...conn.agents.get(agent.id), ...agent };
+ conn.agents.set(agent.id, merged);
+ instanceEvents.emit('peer:agent:updated', { peerId: peer.id, agent: merged });
});
// Agent output (streaming)
- socket.on('cos:agent:output', (data) => {
- instanceEvents.emit('peer:agent:output', { peerId: peer.id, ...data });
+ onPeerAgentEvent('cos:agent:output', (data) => {
+ if (!isPlainObject(data)) return;
+ instanceEvents.emit('peer:agent:output', { ...data, peerId: peer.id });
});
// Agent completed
- socket.on('cos:agent:completed', (data) => {
- const agent = data.agent || data;
+ onPeerAgentEvent('cos:agent:completed', (data) => {
+ const agent = relayedAgent(data);
+ if (!agent) return;
conn.agents.delete(agent.id);
instanceEvents.emit('peer:agent:completed', { peerId: peer.id, agent });
instanceEvents.emit('peer:agents:updated', {
@@ -111,7 +130,8 @@ async function fetchPeerAgents(conn) {
const res = await peerFetch(url, { signal }, peer);
if (!res.ok) return;
const data = await res.json();
- const agents = data.running || data.agents || [];
+ const listed = data?.running || data?.agents;
+ const agents = Array.isArray(listed) ? listed.map(relayedAgent).filter(Boolean) : [];
conn.agents.clear();
for (const agent of agents) {
conn.agents.set(agent.id, agent);
diff --git a/server/services/peerSocketRelay.test.js b/server/services/peerSocketRelay.test.js
new file mode 100644
index 0000000000..7ed81ad798
--- /dev/null
+++ b/server/services/peerSocketRelay.test.js
@@ -0,0 +1,97 @@
+/**
+ * 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]) => /spawned|updated$|completed/.test(event) && event !== 'peer:agents:updated');
+ 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' });
+ for (const [event, payload] of recorder.seen.filter(([name]) => name === 'peer:agents:updated')) {
+ expect(payload.agents.every((agent) => typeof agent?.id === 'string' && agent.id), event).toBe(true);
+ }
+ });
+});