Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
14.3 KB
Raw Blame
// Ported from the CLI (omnirush-cli test/box-ports.test.js): a server the
// agent starts in a box with its own network (Docker, Podman) answers at the
// same port on this computer's 127.0.0.1: the project's box run lists the
// box's listeners through boxd and carries each connection through a boxd
// stream (ports.ts). No container runtime here: a stand-in boxd speaks the
// wire format (box/go/proto) and dials local servers.
import { describe, expect, test } from "bun:test";
import { mkdirSync, mkdtempSync } from "node:fs";
import net from "node:net";
import os from "node:os";
import path from "node:path";

import { connectPort, listPorts, type BoxEndpoint, type BoxListener } from "./client.js";
import { bwrapDriver } from "./backends/bwrap.js";
import { containerDriver } from "./backends/container.js";
import { wslDriver } from "./backends/wsl.js";
import type { Box } from "./box.js";
import { boxRun, type ReadyPlan } from "./launch.js";
import { forwardable, portForwards, portLine, type PortForwardOptions, type PortForwards } from "./ports.js";

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
async function until(fn: () => boolean, ms = 3_000): Promise<boolean> {
  const end = Date.now() + ms;
  while (Date.now() < end) { if (fn()) return true; await sleep(20); }
  return false;
}

function frame(kind: string, payload: Buffer = Buffer.alloc(0)): Buffer {
  const head = Buffer.alloc(5);
  head[0] = kind.charCodeAt(0);
  head.writeUInt32BE(payload.length, 1);
  return Buffer.concat([head, payload]);
}

async function freePort(): Promise<number> {
  const server = net.createServer();
  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
  const { port } = server.address() as net.AddressInfo;
  await new Promise<void>((resolve) => server.close(() => resolve()));
  return port;
}

/** A server that upper-cases what it reads and answers with it once the client half-closes. */
async function upperServer(): Promise<net.Server> {
  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
    const parts: Buffer[] = [];
    socket.on("data", (chunk: Buffer) => parts.push(chunk));
    socket.on("end", () => socket.end(Buffer.concat(parts).toString("utf8").toUpperCase()));
  });
  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
  return server;
}
const portOf = (server: net.Server) => (server.address() as net.AddressInfo).port;

/** A stand-in boxd: op "ports" answers `ports()` ("unknown op" when `old`), op "connect" dials `target(port)` here. */
async function fakeBoxd({ token = "tok", ports = () => [] as BoxListener[], target = (p: number) => p, old = false }: { token?: string; ports?: () => BoxListener[]; target?: (port: number) => number; old?: boolean } = {}) {
  const calls: Array<{ op: string; port?: number; token?: string }> = [];
  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
    let buffered = Buffer.alloc(0);
    const onData = (chunk: Buffer) => {
      buffered = Buffer.concat([buffered, chunk]);
      const nl = buffered.indexOf(0x0a);
      if (nl < 0) return;
      socket.removeListener("data", onData);
      const req = JSON.parse(buffered.subarray(0, nl).toString("utf8"));
      const rest = buffered.subarray(nl + 1);
      calls.push(req);
      const fail = (text: string) => socket.end(Buffer.concat([frame("E", Buffer.from(text)), frame("x", Buffer.from(JSON.stringify({ code: 125 })))]));
      if (req.token !== token) return fail("unauthorized");
      if (old || (req.op !== "ports" && req.op !== "connect")) return fail(`unknown op "${req.op}"`);
      if (req.op === "ports") {
        socket.end(Buffer.concat([frame("d", Buffer.from(JSON.stringify(ports()))), frame("x", Buffer.from(JSON.stringify({ code: 0 })))]));
        return;
      }
      const inner = net.connect({ host: "127.0.0.1", port: target(req.port), allowHalfOpen: true });
      inner.once("error", () => fail(`nothing answers on port ${req.port} in the sandbox`));
      inner.once("connect", () => {
        socket.write(frame("d", Buffer.from('{"ok":true}')));
        if (rest.length) inner.write(rest);
        socket.pipe(inner);
        inner.pipe(socket);
      });
    };
    socket.on("data", onData);
    socket.on("error", () => {});
  });
  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
  const endpoint: BoxEndpoint = { host: "127.0.0.1", port: portOf(server), token };
  return { server, calls, endpoint };
}

/** Send `text` to 127.0.0.1:<port>, half-close, read the answer. */
function roundTrip(port: number, text: string): Promise<string> {
  return new Promise((resolve, reject) => {
    const socket = net.connect({ host: "127.0.0.1", port, allowHalfOpen: true });
    const parts: Buffer[] = [];
    socket.on("data", (chunk: Buffer) => parts.push(chunk));
    socket.on("end", () => { socket.end(); resolve(Buffer.concat(parts).toString("utf8")); });
    socket.on("error", reject);
    socket.once("connect", () => socket.end(text));
  });
}

describe("box ports on this computer", () => {
  test("the backends that need forwards say so; bwrap and the WSL distro share or forward localhost", () => {
    expect(containerDriver.forwardsPorts).toBe(false);
    expect(bwrapDriver.forwardsPorts).not.toBe(false);
    expect(wslDriver.forwardsPorts).not.toBe(false);
  });

  test("which box ports are forwarded, and the one line", () => {
    expect(forwardable(8765)).toBe(true);
    expect(forwardable(1023)).toBe(false);
    expect(forwardable(65536)).toBe(false);
    expect(forwardable(7777)).toBe(false);
    expect(forwardable(3000, new Set())).toBe(true);
    expect(portLine(8765)).toBe("Port 8765 in the sandbox is open on this computer at http://127.0.0.1:8765");
  });

  test("client: ports lists the box's listeners; connect streams both ways; an old boxd reads as null", async () => {
    const inner = await upperServer();
    const boxd = await fakeBoxd({ ports: () => [{ port: 3000, addr: "0.0.0.0" }], target: () => portOf(inner) });
    try {
      expect(await listPorts(boxd.endpoint)).toEqual([{ port: 3000, addr: "0.0.0.0" }]);
      const { socket, head } = await connectPort(boxd.endpoint, 3000);
      expect(head.length).toBe(0);
      const parts: Buffer[] = [];
      socket.on("data", (chunk: Buffer) => parts.push(chunk));
      const ended = new Promise((resolve) => socket.on("end", resolve));
      socket.resume();
      socket.end("hello box");
      await ended;
      expect(Buffer.concat(parts).toString("utf8")).toBe("HELLO BOX");
      await expect(connectPort({ ...boxd.endpoint, token: "nope" }, 3000)).rejects.toThrow(/unauthorized/);
    } finally {
      boxd.server.close();
      inner.close();
    }
    const old = await fakeBoxd({ old: true });
    try {
      expect(await listPorts(old.endpoint)).toBeNull();
    } finally {
      old.server.close();
    }
  });

  test("a new box listener opens on 127.0.0.1 here, carries connections, closes when it goes", async () => {
    const port = await freePort();
    const inner = await upperServer();
    let listening: BoxListener[] = [{ port, addr: "0.0.0.0" }, { port: 80, addr: "0.0.0.0" }, { port: 7777, addr: "0.0.0.0" }];
    const boxd = await fakeBoxd({ ports: () => listening, target: () => portOf(inner) });
    const opened: Array<[number, string]> = [];
    const closed: Array<[number, string]> = [];
    const forwards = portForwards({ endpoint: () => boxd.endpoint, timers: false, onOpen: (p, line) => opened.push([p, line]), onClose: (p, why) => closed.push([p, why]) });
    try {
      await forwards.tick();
      expect(forwards.ports()).toEqual([port]);
      expect(opened).toEqual([[port, portLine(port)]]);
      expect(await roundTrip(port, "page please")).toBe("PAGE PLEASE");
      expect(await Promise.all([roundTrip(port, "one"), roundTrip(port, "two")])).toEqual(["ONE", "TWO"]);
      expect(boxd.calls.filter((c) => c.op === "connect").length).toBe(3);
      listening = [];
      await forwards.tick();
      expect(forwards.ports()).toEqual([]);
      expect(closed).toEqual([[port, "gone"]]);
      await expect(roundTrip(port, "x")).rejects.toThrow();
    } finally {
      forwards.close();
      boxd.server.close();
      inner.close();
    }
  });

  test("a port this computer already uses stays its own (said once); nothing beyond 127.0.0.1", async () => {
    const mine = await upperServer();
    const port = portOf(mine);
    const inner = await upperServer();
    const free = await freePort();
    const boxd = await fakeBoxd({ ports: () => [{ port, addr: "0.0.0.0" }, { port: free, addr: "127.0.0.1" }], target: () => portOf(inner) });
    const logged: Array<[string, string]> = [];
    const forwards = portForwards({ endpoint: () => boxd.endpoint, timers: false, log: (level, message) => logged.push([level, message]) });
    try {
      await forwards.tick();
      await forwards.tick();
      expect(forwards.ports()).toEqual([free]);
      expect(logged.filter((l) => l[1] === "box port not forwarded: in use on this computer").length).toBe(1);
      expect(await roundTrip(port, "host")).toBe("HOST");
      const other = Object.values(os.networkInterfaces()).flat().find((i) => i && i.family === "IPv4" && !i.internal);
      if (other) {
        await expect(new Promise<void>((resolve, reject) => {
          const s = net.connect({ host: other.address, port: free });
          s.once("connect", () => { s.destroy(); resolve(); });
          s.once("error", reject);
        })).rejects.toThrow();
      }
    } finally {
      forwards.close();
      boxd.server.close();
      inner.close();
      mine.close();
    }
  });

  test("none while the box is not usable; an old boxd stops the poll; close() ends every forward", async () => {
    const port = await freePort();
    const inner = await upperServer();
    const boxd = await fakeBoxd({ ports: () => [{ port, addr: "0.0.0.0" }], target: () => portOf(inner) });
    let ep: BoxEndpoint | null = null;
    const forwards = portForwards({ endpoint: () => ep, timers: false });
    try {
      await forwards.tick();
      expect(boxd.calls.length).toBe(0);
      ep = boxd.endpoint;
      await forwards.tick();
      expect(forwards.ports()).toEqual([port]);
      ep = { ...boxd.endpoint, port: await freePort() };
      await forwards.tick();
      expect(forwards.ports()).toEqual([port]);
      forwards.close();
      expect(forwards.ports()).toEqual([]);
      await expect(roundTrip(port, "x")).rejects.toThrow();
    } finally {
      forwards.close();
      boxd.server.close();
      inner.close();
    }
    const old = await fakeBoxd({ old: true });
    const logged: string[] = [];
    const legacy = portForwards({ endpoint: () => old.endpoint, timers: false, log: (_level, message) => logged.push(message) });
    try {
      await legacy.tick();
      await legacy.tick();
      expect(old.calls.length).toBe(1);
      expect(logged[0]).toMatch(/older version/);
    } finally {
      legacy.close();
      old.server.close();
    }
  });

  test("the poll runs on its own every pollMs", async () => {
    const port = await freePort();
    const inner = await upperServer();
    let listening: BoxListener[] = [];
    const boxd = await fakeBoxd({ ports: () => listening, target: () => portOf(inner) });
    const forwards = portForwards({ endpoint: () => boxd.endpoint, pollMs: 30 });
    try {
      listening = [{ port, addr: "::" }];
      expect(await until(() => forwards.ports().includes(port))).toBe(true);
      expect(await roundTrip(port, "late server")).toBe("LATE SERVER");
    } finally {
      forwards.close();
      boxd.server.close();
      inner.close();
    }
  });

  test("boxRun: no port forwards without the required sandbox (as before), whatever the backend", () => {
    const box = { ready: true, error: null, endpoint: { host: "127.0.0.1", port: 1, token: "t" }, setTurn() {} };
    const made: PortForwardOptions[] = [];
    const stub = (opts: PortForwardOptions): PortForwards => { made.push(opts); return { tick: async () => {}, ports: () => [], close() {} }; };
    for (const backend of ["docker", "podman", "apple", "wslc"]) {
      const home = mkdtempSync(path.join(os.tmpdir(), "box-ports-"));
      mkdirSync(path.join(home, "boxes"), { recursive: true });
      const plan = { box: { key: "k1", home, root: "/p", runtime: { name: backend, backend, bin: "/x/rt" } }, notice: null, shell: "/x/boxsh", phase: "ready", start: async () => box as unknown as Box } as unknown as ReadyPlan;
      boxRun(plan, { forwards: stub, env: {}, ping: (async () => ({})) as never }).close();
    }
    expect(made.length).toBe(0);
  });

  test("boxRun under required: forwards only for a backend with its own network, unless OMNIRUSH_BOX_PORTS=off; closed with the run", async () => {
    const box = { ready: true, error: null, endpoint: { host: "127.0.0.1", port: 1, token: "t" }, setTurn() {} };
    const plan = (backend: string): ReadyPlan => {
      const home = mkdtempSync(path.join(os.tmpdir(), "box-ports-"));
      mkdirSync(path.join(home, "boxes"), { recursive: true });
      return { box: { key: "k1", home, root: "/p", runtime: { name: backend, backend, bin: "/x/rt" } }, notice: null, shell: "/x/boxsh", phase: "ready", start: async () => box as unknown as Box } as unknown as ReadyPlan;
    };
    const made: Array<{ opts: PortForwardOptions; closed: boolean }> = [];
    const stub = (opts: PortForwardOptions): PortForwards => {
      const entry = { opts, closed: false };
      made.push(entry);
      return { tick: async () => {}, ports: () => [4000], close() { entry.closed = true; } };
    };
    const said: unknown[] = [];
    const docker = boxRun(plan("docker"), { forwards: stub, env: {}, ping: (async () => ({})) as never, onPort: (e) => said.push(e), required: true });
    expect(made.length).toBe(1);
    await docker.ready();
    expect(made[0]!.opts.endpoint()).toEqual(box.endpoint);
    expect(docker.forwardedPorts?.()).toEqual([4000]);
    made[0]!.opts.onOpen!(3000, portLine(3000));
    expect(said).toEqual([{ port: 3000, line: portLine(3000), open: true }]);
    docker.close();
    expect(made[0]!.closed).toBe(true);
    expect(made[0]!.opts.endpoint()).toBeNull();
    boxRun(plan("bwrap"), { forwards: stub, env: {}, required: true }).close();
    boxRun(plan("wsl"), { forwards: stub, env: {}, required: true }).close();
    boxRun(plan("podman"), { forwards: stub, env: { OMNIRUSH_BOX_PORTS: "off" }, required: true }).close();
    expect(made.length).toBe(1);
  });
});