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
import { once } from 'node:events';
import { createServer, request as httpRequest } from 'node:http';
import { afterEach, describe, expect, it } from 'vitest';
import {
DEFAULT_UPGRADE_TIMEOUT_MS,
installUpgradeFallback,
markUpgradeClaimed,
mountUpgradeFallback,
} from './upgradeFallback.js';
describe('upgradeFallback', () => {
const servers = [];
const sockets = [];
const listen = async (server) => {
server.on('connection', (s) => sockets.push(s));
server.listen(0, '127.0.0.1');
await once(server, 'listening');
servers.push(server);
return server.address().port;
};
afterEach(async () => {
while (sockets.length > 0) {
const socket = sockets.pop();
try {
socket?.destroy();
} catch {}
}
while (servers.length > 0) {
const server = servers.pop();
server.closeAllConnections?.();
await new Promise((resolve) => {
if (!server.listening) {
resolve();
return;
}
server.close(() => resolve());
});
}
});
const sendRawUpgrade = (port, path = '/unclaimed') => {
const req = httpRequest({
hostname: '127.0.0.1',
port,
path,
headers: {
Connection: 'Upgrade',
Upgrade: 'websocket',
},
});
req.on('upgrade', (_res, socket) => {
sockets.push(socket);
});
req.on('socket', (socket) => {
sockets.push(socket);
});
req.on('error', () => {});
req.end();
return req;
};
it('exports default timeout and aliases', () => {
expect(DEFAULT_UPGRADE_TIMEOUT_MS).toBe(1000);
expect(mountUpgradeFallback).toBe(installUpgradeFallback);
});
it('handles null or invalid server gracefully', () => {
const cleanup1 = installUpgradeFallback(null);
expect(typeof cleanup1).toBe('function');
cleanup1();
const cleanup2 = installUpgradeFallback({});
expect(typeof cleanup2).toBe('function');
cleanup2();
});
it('ends an unclaimed upgrade socket after timeout', async () => {
const server = createServer();
installUpgradeFallback(server, { timeoutMs: 50 });
const port = await listen(server);
let clientSocket = null;
await new Promise((resolve) => {
const req = httpRequest({
hostname: '127.0.0.1',
port,
path: '/unknown-upgrade',
headers: {
Connection: 'Upgrade',
Upgrade: 'websocket',
},
});
req.on('socket', (s) => {
clientSocket = s;
sockets.push(s);
});
req.on('close', resolve);
req.on('error', resolve);
req.end();
});
await new Promise((resolve) => setTimeout(resolve, 80));
expect(clientSocket?.destroyed ?? true).toBe(true);
});
it('does not end a socket marked portosUpgradeClaimed', async () => {
const server = createServer();
let serverSocket = null;
server.on('upgrade', (_req, socket) => {
serverSocket = socket;
markUpgradeClaimed(socket);
});
installUpgradeFallback(server, { timeoutMs: 50 });
const port = await listen(server);
sendRawUpgrade(port, '/claimed');
await new Promise((resolve) => setTimeout(resolve, 80));
expect(serverSocket).not.toBeNull();
expect(serverSocket.destroyed).toBe(false);
expect(serverSocket.writable).toBe(true);
});
it('does not end a socket that has written bytes', async () => {
const server = createServer();
let serverSocket = null;
server.on('upgrade', (_req, socket) => {
serverSocket = socket;
socket.write('HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
});
installUpgradeFallback(server, { timeoutMs: 50 });
const port = await listen(server);
sendRawUpgrade(port, '/socket.io');
await new Promise((resolve) => setTimeout(resolve, 80));
expect(serverSocket.bytesWritten).toBeGreaterThan(0);
expect(serverSocket.destroyed).toBe(false);
});
it('ends an unclaimed upgrade even on a keep-alive socket with previous bytesWritten', async () => {
const server = createServer((req, res) => {
res.writeHead(200, { 'Content-Length': '4', Connection: 'keep-alive' });
res.end('pong');
});
installUpgradeFallback(server, { timeoutMs: 50 });
const port = await listen(server);
const { createConnection } = await import('node:net');
const socket = createConnection({ host: '127.0.0.1', port });
sockets.push(socket);
await once(socket, 'connect');
// First, complete an ordinary HTTP request over the connection
socket.write('GET /probe HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: keep-alive\r\n\r\n');
await once(socket, 'data');
// Next, send an unclaimed upgrade over the same keep-alive socket
socket.write('GET /unclaimed HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
await new Promise((resolve) => setTimeout(resolve, 180));
expect(socket.destroyed).toBe(true);
});
it('prevents duplicate installation and cleans up properly', async () => {
const server = createServer();
const cleanup1 = installUpgradeFallback(server);
const countBefore = server.listenerCount('upgrade');
const cleanup2 = installUpgradeFallback(server);
expect(server.listenerCount('upgrade')).toBe(countBefore);
cleanup1();
expect(server.listenerCount('upgrade')).toBe(countBefore - 1);
cleanup2();
});
});