Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.4 KB
Raw Blame
import { createHash } from 'node:crypto';
import { createServer as createHttpServer, get as httpGet } from 'node:http';
import type { AddressInfo, Socket } from 'node:net';
import { createServer } from 'vite';
import { expect, it } from 'vitest';
import { localDevServer } from './local-dev-server';

it('proxies real HTTP and WebSocket requests through Vite without rewriting paths', async () => {
  const sockets = new Set<Socket>();
  const backend = createHttpServer((req, res) => {
    res.setHeader('Content-Type', 'application/json');
    res.setHeader('Set-Cookie', 'proxy-test=ok; Path=/; SameSite=Lax');
    res.end(
      JSON.stringify({
        url: req.url,
        method: req.method,
        cookie: req.headers.cookie,
        host: req.headers.host,
        forwardedHost: req.headers['x-forwarded-host'],
      })
    );
  });
  // Minimal server-to-client WebSocket frame: no additional test dependency.
  backend.on('connection', (socket) => {
    sockets.add(socket);
    socket.on('close', () => sockets.delete(socket));
  });
  backend.on('upgrade', (req, socket) => {
    const accept = createHash('sha1')
      .update(
        `${req.headers['sec-websocket-key']}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`
      )
      .digest('base64');
    socket.write(
      `HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`
    );
    const payload = Buffer.from(req.url ?? '');
    socket.write(Buffer.concat([Buffer.from([0x81, payload.length]), payload]));
  });
  await new Promise<void>((resolve) => backend.listen(0, '127.0.0.1', resolve));
  const target = `http://127.0.0.1:${(backend.address() as AddressInfo).port}`;
  const vite = await createServer({
    configFile: false,
    appType: 'custom',
    optimizeDeps: { noDiscovery: true, include: [] },
    server: {
      host: '127.0.0.1',
      port: 0,
      ...localDevServer({
        MACRO_LOCAL_BACKEND_PROXY: target,
        MACRO_LOCAL_HOSTNAME: 'Wolf-Macro-Google',
        MACRO_LOCAL_BACKEND_ROUTES: '/auth,/connection-gateway,/i',
      }),
    },
  });
  try {
    vite.middlewares.use((_req, res) => res.end('frontend'));
    await vite.listen();
    const address = vite.httpServer?.address();
    if (!address || typeof address === 'string')
      throw new Error('Vite has no TCP listener');
    const origin = `http://127.0.0.1:${address.port}`;
    const response = await fetch(`${origin}/auth/health?check=1`, {
      headers: { cookie: 'session=test' },
    });
    expect(await response.json()).toEqual({
      url: '/auth/health?check=1',
      method: 'GET',
      cookie: 'session=test',
      host: new URL(target).host,
      forwardedHost: new URL(origin).host,
    });
    expect(response.headers.get('set-cookie')).toContain('proxy-test=ok');
    // Use Node HTTP: fetch does not reliably preserve an explicit Host header.
    for (const host of ['wolf-macro-google', 'arbitrary-host.example']) {
      const request = (path: string) =>
        new Promise<{ status: number | undefined; body: string }>(
          (resolve, reject) => {
            httpGet(`${origin}${path}`, { headers: { host } }, (res) => {
              let body = '';
              res.setEncoding('utf8');
              res.on('data', (chunk) => {
                body += chunk;
              });
              res.on('end', () => resolve({ status: res.statusCode, body }));
              res.on('error', reject);
            }).on('error', reject);
          }
        );
      if (host === 'arbitrary-host.example') {
        expect((await request('/app/')).status).toBe(403);
        expect((await request('/auth/health')).status).toBe(403);
        continue;
      }
      expect(await request('/app/')).toEqual({ status: 200, body: 'frontend' });
      const proxied = await request('/auth/health');
      expect(proxied.status).toBe(200);
      expect(JSON.parse(proxied.body)).toMatchObject({
        host: new URL(target).host,
        forwardedHost: host,
      });
    }
    const telemetry = await fetch(`${origin}/i/otlp/v1/traces`, {
      method: 'POST',
      body: 'fixture',
    });
    expect(await telemetry.json()).toMatchObject({
      url: '/i/otlp/v1/traces',
      method: 'POST',
    });
    expect(await fetch(`${origin}/authentic`).then((res) => res.text())).toBe(
      'frontend'
    );
    const client = await fetch(`${origin}/@vite/client`).then((res) =>
      res.text()
    );
    expect(client).toContain('import.meta.url');

    const path = '/connection-gateway?check=1';
    const socket = new WebSocket(origin.replace(/^http/, 'ws') + path);
    try {
      const message = await new Promise<string>((resolve, reject) => {
        const timer = setTimeout(
          () => reject(new Error('WebSocket proxy timeout')),
          3000
        );
        socket.addEventListener(
          'message',
          (event) => {
            clearTimeout(timer);
            resolve(String(event.data));
          },
          { once: true }
        );
        socket.addEventListener(
          'error',
          () => {
            clearTimeout(timer);
            reject(new Error('WebSocket proxy failed'));
          },
          { once: true }
        );
      });
      expect(message).toBe(path);
    } finally {
      socket.close();
    }
  } finally {
    for (const socket of sockets) socket.destroy();
    await vite.close();
    await new Promise<void>((resolve) => backend.close(() => resolve()));
  }
});