Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.7 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { execFile } from "node:child_process";
import { mkdtemp, readFile, rm } from "node:fs/promises";
import { createServer as createNetServer } from "node:net";
import { tmpdir } from "node:os";
import { join } from "node:path";
import tls, { type ConnectionOptions } from "node:tls";
import { promisify } from "node:util";

import { probeCloudEndpointTransport, type TransportProbeConnector } from "./agent-context-transport-probe.js";

const execFileAsync = promisify(execFile);
const roots: string[] = [];
const stops: Array<() => Promise<void>> = [];

afterEach(async () => {
  while (stops.length) await stops.pop()?.();
  while (roots.length) {
    const root = roots.pop();
    if (root) await rm(root, { recursive: true, force: true });
  }
});

async function createRoot(): Promise<string> {
  const root = await mkdtemp(join(tmpdir(), "omnirush-transport-probe-"));
  roots.push(root);
  return root;
}

function closeServer(server: tls.Server | ReturnType<typeof createNetServer>): Promise<void> {
  return new Promise((resolve, reject) => {
    server.close((error) => {
      if (error) reject(error);
      else resolve();
    });
  });
}

function listen(server: tls.Server | ReturnType<typeof createNetServer>): Promise<number> {
  return new Promise((resolve, reject) => {
    const onError = (error: Error) => reject(error);
    server.once("error", onError);
    server.listen(0, "127.0.0.1", () => {
      server.removeListener("error", onError);
      const address = server.address();
      if (typeof address === "object" && address !== null) resolve(address.port);
      else reject(new Error("Expected a TCP port"));
    });
  });
}

async function closedLoopbackPort(): Promise<number> {
  const server = createNetServer();
  const port = await listen(server);
  await closeServer(server);
  return port;
}

async function selfSignedCertificate(): Promise<{ key: string; cert: string }> {
  const root = await createRoot();
  const keyPath = join(root, "key.pem");
  const certPath = join(root, "cert.pem");
  await execFileAsync("openssl", [
    "req",
    "-x509",
    "-newkey",
    "rsa:2048",
    "-nodes",
    "-keyout",
    keyPath,
    "-out",
    certPath,
    "-subj",
    "/CN=localhost",
    "-days",
    "1",
    "-addext",
    "subjectAltName=DNS:localhost,IP:127.0.0.1",
  ]);
  return {
    key: await readFile(keyPath, "utf8"),
    cert: await readFile(certPath, "utf8"),
  };
}

async function startSelfSignedTlsServer(): Promise<number> {
  const material = await selfSignedCertificate();
  const server = tls.createServer(material, (socket) => socket.end());
  const port = await listen(server);
  stops.push(() => closeServer(server));
  return port;
}

function captureConnectorOptions(): { connector: TransportProbeConnector; options: ConnectionOptions[] } {
  const options: ConnectionOptions[] = [];
  return {
    connector: (connectionOptions) => {
      options.push(connectionOptions);
      throw new Error("captured options");
    },
    options,
  };
}

function onlyCapturedOption(options: ConnectionOptions[]): ConnectionOptions {
  const option = options[0];
  if (!option || options.length !== 1) throw new Error(`Expected one connector call, got ${options.length}`);
  return option;
}

describe("probeCloudEndpointTransport", () => {
  test("passes SNI servername for DNS endpoints", async () => {
    const capture = captureConnectorOptions();

    await probeCloudEndpointTransport({
      endpointUrl: "https://example.com/mcp/agent",
      performProbe: true,
      timeoutMs: 1_000,
      connector: capture.connector,
      env: {},
    });

    const options = onlyCapturedOption(capture.options);
    expect(options.host).toBe("example.com");
    expect(options.servername).toBe("example.com");
  });

  test("omits SNI servername for IPv4 endpoints", async () => {
    const capture = captureConnectorOptions();

    await probeCloudEndpointTransport({
      endpointUrl: "https://127.0.0.1:444/mcp/agent",
      performProbe: true,
      timeoutMs: 1_000,
      connector: capture.connector,
      env: {},
    });

    const options = onlyCapturedOption(capture.options);
    expect(options.host).toBe("127.0.0.1");
    expect(options.port).toBe(444);
    expect("servername" in options).toBe(false);
  });

  test("omits SNI servername and strips brackets for IPv6 endpoints", async () => {
    const capture = captureConnectorOptions();

    await probeCloudEndpointTransport({
      endpointUrl: "https://[::1]/mcp/agent",
      performProbe: true,
      timeoutMs: 1_000,
      connector: capture.connector,
      env: {},
    });

    const options = onlyCapturedOption(capture.options);
    expect(options.host).toBe("::1");
    expect(options.port).toBe(443);
    expect("servername" in options).toBe(false);
  });

  test("captures certificate-chain evidence for a self-signed endpoint without credentials", async () => {
    const port = await startSelfSignedTlsServer();
    const result = await probeCloudEndpointTransport({
      endpointUrl: `https://127.0.0.1:${port}/mcp/agent`,
      performProbe: true,
      timeoutMs: 1_500,
      env: {},
    });

    expect(result.verifiedHandshake).toBe("failed");
    if (result.verifyErrorCode === null) throw new Error("Expected a TLS verification code");
    expect([
      "DEPTH_ZERO_SELF_SIGNED_CERT",
      "SELF_SIGNED_CERT_IN_CHAIN",
      "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
    ]).toContain(result.verifyErrorCode);
    expect(result.dnsResolved).toBe(true);
    expect(result.tcpConnected).toBe(true);
    expect(result.servedChainLength).toBe(1);
    expect(result.servedChain[0]).toMatchObject({
      subjectCN: "localhost",
      issuerCN: "localhost",
      selfIssued: true,
    });
    expect(result.endpointOrigin).toBe(`https://127.0.0.1:${port}`);
  });

  test("classifies a refused loopback TCP connection", async () => {
    const port = await closedLoopbackPort();
    const result = await probeCloudEndpointTransport({
      endpointUrl: `https://127.0.0.1:${port}/mcp/agent`,
      performProbe: true,
      timeoutMs: 1_000,
      env: {},
    });

    expect(result.verifiedHandshake).toBe("failed");
    expect(result.verifyErrorCode).not.toBe("ERR_INVALID_ARG_VALUE");
    expect(result.verifyErrorCode).toBe("ECONNREFUSED");
    expect(result.dnsResolved).toBe(true);
    expect(result.tcpConnected).toBe(false);
    expect(result.servedChainLength).toBeNull();
  });

  test("classifies DNS lookup failures", async () => {
    const result = await probeCloudEndpointTransport({
      endpointUrl: "https://no-such-host.invalid/mcp/agent",
      performProbe: true,
      timeoutMs: 1_500,
      env: {},
    });

    expect(result.verifiedHandshake).toBe("failed");
    expect(result.verifyErrorCode).toBe("ENOTFOUND");
    expect(result.dnsResolved).toBe(false);
    expect(result.tcpConnected).toBe(false);
  });

  test("always includes local trust evidence", async () => {
    const result = await probeCloudEndpointTransport({
      endpointUrl: null,
      performProbe: false,
      env: { NODE_EXTRA_CA_CERTS: "/virtual/corporate.pem" },
      caFileReader: () => "-----BEGIN CERTIFICATE-----\none\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ntwo\n-----END CERTIFICATE-----",
    });

    expect(result.verifiedHandshake).toBe("not-performed");
    expect(typeof result.nodeExtraCaCertsSet).toBe("boolean");
    expect(result.nodeExtraCaCertsSet).toBe(true);
    expect(result.nodeExtraCaCertsFileReadable).toBe(true);
    expect(result.nodeExtraCaCertsCertCount).toBe(2);
    expect(
      result.systemCaCertificateCount === null || typeof result.systemCaCertificateCount === "number",
    ).toBe(true);
    expect(
      result.bundledCaCertificateCount === null || typeof result.bundledCaCertificateCount === "number",
    ).toBe(true);
  });
});