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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
/**
* Peer Socket Relay
*
* Connects as a Socket.IO client to each online peer, subscribes to cos:agent:*
* events, and re-emits them locally through instanceEvents for the client UI.
*/
import { io } from 'socket.io-client';
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
*/
export function connectToPeer(peer) {
if (peerConnections.has(peer.id)) return;
const url = peerBaseUrl(peer);
const socket = io(url, {
reconnection: true,
reconnectionAttempts: 5,
reconnectionDelay: 5000,
timeout: CONNECT_TIMEOUT_MS,
// peerSocketOptionsFor injects the same credential headers peerFetch sends
// (the pair token, and Basic until the receiver confirms the token).
...peerSocketOptionsFor(peer)
});
// `host` is required so fetchPeerAgents() can rebuild the HTTPS URL via peerBaseUrl();
// `auth`, `syncSecret` and `peerAuthAccepted` are carried so its peerFetch
// presents the same credential as the probe (#8356).
const conn = {
socket,
agents: new Map(),
peer: {
id: peer.id, name: peer.name, address: peer.address, host: peer.host ?? null, port: peer.port, auth: peer.auth ?? null,
syncSecret: peer.syncSecret ?? null, peerAuthAccepted: peer.peerAuthAccepted === true,
}
};
peerConnections.set(peer.id, conn);
socket.on('connect', () => {
console.log(`🔗 Peer relay connected: ${peer.name} (${url})`);
socket.emit('cos:subscribe');
// Fetch initial agent state via HTTP
void fetchPeerAgents(conn);
});
socket.on('disconnect', () => {
console.log(`🔗 Peer relay disconnected: ${peer.name}`);
conn.agents.clear();
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
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', {
peerId: peer.id,
agents: Array.from(conn.agents.values())
});
});
// Agent updated
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)
onPeerAgentEvent('cos:agent:output', (data) => {
if (!isPlainObject(data)) return;
instanceEvents.emit('peer:agent:output', { ...data, peerId: peer.id });
});
// Agent completed
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', {
peerId: peer.id,
agents: Array.from(conn.agents.values())
});
});
}
/**
* Fetch current agents from peer via HTTP and populate initial state
*/
async function fetchPeerAgents(conn) {
const { peer } = conn;
const url = `${peerBaseUrl(peer)}/api/cos/agents`;
await withAbortTimeout(CONNECT_TIMEOUT_MS, async (signal) => {
const res = await peerFetch(url, { signal }, peer);
if (!res.ok) return;
const data = await res.json();
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);
}
instanceEvents.emit('peer:agents:updated', {
peerId: peer.id,
agents: Array.from(conn.agents.values())
});
console.log(`🔗 Peer ${peer.name}: ${agents.length} active agent(s)`);
}).catch(() => {
// Silent — agents will populate via socket events
});
}
/**
* Disconnect from a peer and clean up
*/
export function disconnectFromPeer(peerId) {
const conn = peerConnections.get(peerId);
if (!conn) return;
conn.socket.disconnect();
conn.agents.clear();
peerConnections.delete(peerId);
instanceEvents.emit('peer:agents:updated', { peerId, agents: [] });
console.log(`🔗 Peer relay cleaned up: ${conn.peer.name}`);
}