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

13.5 KB
Raw Blame
import { once } from 'node:events';
import { createServer, request as httpRequest } from 'node:http';
import express from 'express';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { WebSocket, WebSocketServer } from 'ws';
import { Server as SocketIoServer } from 'socket.io';
import { io as SocketIoClient } from 'socket.io-client';
import { installUpgradeFallback } from '../lib/upgradeFallback.js';
import {
  createEidoverseExpressMiddleware,
  embedParentOrigin,
  mountEidoverseWebSocket,
  stripEidoverseHostPrefix,
  isEidoverseRootProxyPath,
} from './eidoverseProxy.js';

const HOST_DESCRIPTOR = Object.freeze({
  id: 'hst_0123456789ab',
  kind: 'portos',
  label: 'Luminous Systems Garden',
  version: '9.9.9',
  caps: { eido: false },
});
vi.mock('./eidoverseWorld.js', () => ({
  readEidoverseHostDescriptor: vi.fn(async () => HOST_DESCRIPTOR),
}));

const servers = [];
const webSocketServers = [];
const webSocketClients = [];
const ioServers = [];

const listen = async (server) => {
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  servers.push(server);
  return server.address().port;
};

const closeServer = (server) => new Promise((resolve, reject) => {
  if (!server.listening) {
    resolve();
    return;
  }
  server.close((error) => (error ? reject(error) : resolve()));
});

const rawGet = (port, path, hostHeader) => new Promise((settle, reject) => {
  const probe = httpRequest({ host: '127.0.0.1', port, path, headers: { host: hostHeader } }, (response) => {
    let body = '';
    response.setEncoding('utf8');
    response.on('data', (chunk) => { body += chunk; });
    response.on('end', () => settle({ status: response.statusCode, body }));
  });
  probe.once('error', reject);
  probe.end();
});

afterEach(async () => {
  webSocketClients.splice(0).forEach((client) => client.terminate());
  await Promise.all(webSocketServers.splice(0).map((server) => new Promise((resolve) => server.close(resolve))));
  while (ioServers.length > 0) {
    const io = ioServers.pop();
    try {
      io?.close();
    } catch {}
  }
  await Promise.all(servers.splice(0).map(closeServer));
});

describe('eidoverse proxy route helpers', () => {
  it('strips the /eidoverse-host prefix for relative assets', () => {
    expect(stripEidoverseHostPrefix('/eidoverse-host/')).toBe('/');
    expect(stripEidoverseHostPrefix('/eidoverse-host')).toBe('/');
    expect(stripEidoverseHostPrefix('/eidoverse-host/main.js')).toBe('/main.js');
    expect(stripEidoverseHostPrefix('/eidoverse-host/a?b=1')).toBe('/a?b=1');
    expect(stripEidoverseHostPrefix('/version')).toBe(null);
  });

  it('recognizes exact and prefix root allowlist entries from routes.ts', () => {
    expect(isEidoverseRootProxyPath('/version')).toBe(true);
    expect(isEidoverseRootProxyPath('/ws')).toBe(true);
    expect(isEidoverseRootProxyPath('/library/foo.glb')).toBe(true);
    expect(isEidoverseRootProxyPath('/node_modules/three/build/three.module.js')).toBe(true);
    expect(isEidoverseRootProxyPath('/AGENTS.md')).toBe(true);
    expect(isEidoverseRootProxyPath('/eidoverse')).toBe(false);
    expect(isEidoverseRootProxyPath('/api/settings')).toBe(false);
  });

  it('preserves a non-5555 Host port in same-origin embed parent origins', () => {
    const req = { headers: { host: '127.0.0.1:15555' } };
    expect(embedParentOrigin(req, 'http', 'same-origin')).toBe('http://127.0.0.1:15555');
    expect(embedParentOrigin(req, 'http', 'bridge')).toMatch(/:5555$/);
  });
});

describe('main-server eidoverse reverse-proxy', () => {
  const mountApp = async ({ active, upstreamPort, spaBody = 'spa' }) => {
    const app = express();
    app.use(createEidoverseExpressMiddleware({
      isActive: () => active,
      targetHost: '127.0.0.1',
      targetPort: upstreamPort,
      getProtocol: () => 'http',
    }));
    app.use((_req, res) => {
      res.status(200).type('text/plain').send(spaBody);
    });
    const server = createServer(app);
    mountEidoverseWebSocket(server, {
      isActive: () => active,
      targetHost: '127.0.0.1',
      targetPort: upstreamPort,
      getProtocol: () => 'http',
    });
    return listen(server);
  };

  it('strips /eidoverse-host and forwards to the sequencer', async () => {
    const upstreamPort = await listen(createServer((req, res) => {
      res.writeHead(200, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ path: req.url }));
    }));
    const port = await mountApp({ active: true, upstreamPort });

    const response = await fetch(`http://127.0.0.1:${port}/eidoverse-host/main.js?v=1`);
    expect(response.status).toBe(200);
    expect(await response.json()).toEqual({ path: '/main.js?v=1' });
  });

  it('proxies root /version only while the host is active', async () => {
    const upstreamPort = await listen(createServer((req, res) => {
      res.writeHead(200, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ path: req.url, from: 'eidoverse' }));
    }));

    const activePort = await mountApp({ active: true, upstreamPort, spaBody: 'spa-active' });
    const active = await fetch(`http://127.0.0.1:${activePort}/version`);
    expect(active.status).toBe(200);
    expect(await active.json()).toEqual({ path: '/version', from: 'eidoverse' });

    const inactivePort = await mountApp({ active: false, upstreamPort, spaBody: 'spa-inactive' });
    const inactive = await fetch(`http://127.0.0.1:${inactivePort}/version`);
    expect(inactive.status).toBe(200);
    expect(await inactive.text()).toBe('spa-inactive');
  });

  it('answers path-mounted /embed-config with the full browser Host as parentOrigin', async () => {
    const upstreamRequests = [];
    const upstreamPort = await listen(createServer((req, res) => {
      upstreamRequests.push(req.url);
      res.writeHead(200);
      res.end('sequencer');
    }));
    const port = await mountApp({ active: true, upstreamPort });

    const result = await rawGet(port, '/eidoverse-host/embed-config', '127.0.0.1:15555');
    expect(result.status).toBe(200);
    expect(JSON.parse(result.body)).toEqual({ parentOrigin: 'http://127.0.0.1:15555' });
    expect(upstreamRequests).toEqual([]);

    const root = await rawGet(port, '/embed-config', '127.0.0.1:15555');
    expect(root.status).toBe(200);
    expect(JSON.parse(root.body)).toEqual({ parentOrigin: 'http://127.0.0.1:15555' });
  });

  it('upgrades root /ws to the sequencer while active', async () => {
    const upstream = createServer();
    const webSocketServer = new WebSocketServer({ server: upstream });
    webSocketServers.push(webSocketServer);
    webSocketServer.on('connection', (socket) => {
      socket.send('ready');
      socket.on('message', (message) => socket.send(`echo:${message}`));
    });
    const upstreamPort = await listen(upstream);
    const port = await mountApp({ active: true, upstreamPort });

    const client = new WebSocket(`ws://127.0.0.1:${port}/ws`);
    webSocketClients.push(client);
    const first = once(client, 'message');
    await once(client, 'open');
    expect(String((await first)[0])).toBe('ready');
    const echo = once(client, 'message');
    client.send('ping');
    expect(String((await echo)[0])).toBe('echo:ping');
    client.close();
    await once(client, 'close');
    webSocketClients.pop();
  });

  it('forwards a JSON POST body when mounted in the production order', async () => {
    let receivedBody = null;
    let receivedHeaders = null;
    const upstreamPort = await listen(createServer((req, res) => {
      receivedHeaders = req.headers;
      let body = '';
      req.setEncoding('utf8');
      req.on('data', (chunk) => { body += chunk; });
      req.on('end', () => {
        receivedBody = body;
        res.writeHead(200, { 'content-type': 'application/json' });
        res.end(JSON.stringify({ ok: true, echo: body ? JSON.parse(body) : null }));
      });
    }));

    // Mirror production order from server/index.js:
    // Eidoverse proxy mounted BEFORE express.json()
    const app = express();
    app.use(createEidoverseExpressMiddleware({
      isActive: () => true,
      targetHost: '127.0.0.1',
      targetPort: upstreamPort,
      getProtocol: () => 'http',
    }));
    app.use(express.json());
    app.use(express.urlencoded({ extended: true }));
    const server = createServer(app);
    const port = await listen(server);

    const payload = { action: 'ping', count: 42 };
    const response = await fetch(`http://127.0.0.1:${port}/eidoverse-host/api/action`, {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
      },
      body: JSON.stringify(payload),
    });

    expect(response.status).toBe(200);
    const data = await response.json();
    expect(data).toEqual({ ok: true, echo: payload });
    expect(receivedBody).toBe(JSON.stringify(payload));
    expect(Number(receivedHeaders['content-length'])).toBe(Buffer.byteLength(JSON.stringify(payload)));
  });

  it('completes a /ws upgrade whose upstream answers after 1.5 s when Socket.IO is attached with destroyUpgrade: false', async () => {
    const upstream = createServer();
    const upstreamWss = new WebSocketServer({ noServer: true });
    webSocketServers.push(upstreamWss);
    upstream.on('upgrade', (req, socket, head) => {
      const timer = setTimeout(() => {
        upstreamWss.handleUpgrade(req, socket, head, (ws) => {
          ws.send('slow-ready');
        });
      }, 1500);
      timer.unref?.();
    });
    const upstreamPort = await listen(upstream);

    const app = express();
    app.use(createEidoverseExpressMiddleware({
      isActive: () => true,
      targetHost: '127.0.0.1',
      targetPort: upstreamPort,
      getProtocol: () => 'http',
    }));
    const server = createServer(app);
    const io = new SocketIoServer(server, {
      destroyUpgrade: false,
      path: '/socket.io',
    });
    ioServers.push(io);
    mountEidoverseWebSocket(server, {
      isActive: () => true,
      targetHost: '127.0.0.1',
      targetPort: upstreamPort,
      getProtocol: () => 'http',
    });
    installUpgradeFallback(server);
    const port = await listen(server);

    const client = new WebSocket(`ws://127.0.0.1:${port}/ws`);
    webSocketClients.push(client);
    const first = once(client, 'message');
    await once(client, 'open');
    expect(String((await first)[0])).toBe('slow-ready');
    client.close();
    await once(client, 'close');
    webSocketClients.pop();
  });

  it('ends an upgrade request for an unclaimed path after a bounded timeout', async () => {
    const app = express();
    const server = createServer(app);
    const io = new SocketIoServer(server, {
      destroyUpgrade: false,
      path: '/socket.io',
    });
    ioServers.push(io);
    mountEidoverseWebSocket(server, {
      isActive: () => true,
      targetHost: '127.0.0.1',
      targetPort: 5556,
      getProtocol: () => 'http',
    });
    installUpgradeFallback(server, { timeoutMs: 100 });
    const port = await listen(server);

    const client = new WebSocket(`ws://127.0.0.1:${port}/unclaimed-upgrade-path`);
    webSocketClients.push(client);
    const closed = await new Promise((resolve) => {
      client.on('close', () => resolve(true));
      client.on('error', () => resolve(true));
    });
    expect(closed).toBe(true);
    expect(client.readyState).toBeGreaterThanOrEqual(WebSocket.CLOSING);
    webSocketClients.pop();
  });

  it('preserves Socket.IO upgrades on the same server when destroyUpgrade: false is set', async () => {
    const app = express();
    const server = createServer(app);
    const io = new SocketIoServer(server, {
      destroyUpgrade: false,
      path: '/socket.io',
    });
    ioServers.push(io);
    mountEidoverseWebSocket(server, {
      isActive: () => true,
      targetHost: '127.0.0.1',
      targetPort: 5556,
      getProtocol: () => 'http',
    });
    installUpgradeFallback(server);
    const port = await listen(server);

    const client = SocketIoClient(`http://127.0.0.1:${port}`, {
      path: '/socket.io',
      transports: ['websocket'],
    });
    await once(client, 'connect');
    expect(client.connected).toBe(true);
    client.disconnect();
  });

  it('preserves Socket.IO upgrades with delayed allowRequest authorization', async () => {
    const app = express();
    const server = createServer(app);
    const io = new SocketIoServer(server, {
      destroyUpgrade: false,
      path: '/socket.io',
      allowRequest: async (_req, callback) => {
        await new Promise((resolve) => setTimeout(resolve, 1500));
        callback(null, true);
      },
    });
    ioServers.push(io);
    installUpgradeFallback(server);
    const port = await listen(server);

    const client = SocketIoClient(`http://127.0.0.1:${port}`, {
      path: '/socket.io',
      transports: ['websocket'],
    });
    await once(client, 'connect');
    expect(client.connected).toBe(true);
    client.disconnect();
  });

  it('ends an unanswered upgrade to /socket.io (without trailing slash) after timeout', async () => {
    const app = express();
    const server = createServer(app);
    const io = new SocketIoServer(server, {
      destroyUpgrade: false,
      path: '/socket.io',
    });
    ioServers.push(io);
    installUpgradeFallback(server, { timeoutMs: 100 });
    const port = await listen(server);

    const client = new WebSocket(`ws://127.0.0.1:${port}/socket.io`);
    webSocketClients.push(client);
    const closed = await new Promise((resolve) => {
      client.on('close', () => resolve(true));
      client.on('error', () => resolve(true));
    });
    expect(closed).toBe(true);
    expect(client.readyState).toBeGreaterThanOrEqual(WebSocket.CLOSING);
    webSocketClients.pop();
  });
});