Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.2 KB
Raw Blame
// Ported from the CLI (omnirush-cli src/box/ports.js); keep the two in step.
// Only types were added here.
//
// A server the agent starts in the box (`npm run dev` on :3000), at the same
// port on this computer's 127.0.0.1, for backends whose box has its own
// network (Docker, Podman, Apple container: driver.forwardsPorts === false).
// bubblewrap shares this computer's network, WSL forwards localhost, and the
// macOS VM forwards its guest's ports: they need none of this.
//
// While the box is in use, its listening ports are read from boxd every
// ~2 s; a new one (1024-65535, not boxd's own, free on this computer) gets a
// listener on 127.0.0.1:<port> here, and each connection to it goes through
// its own boxd stream (op "connect"). The listener closes when the box stops
// listening there or the box is let go. Nothing is ever bound beyond 127.0.0.1.

import net from "node:net";

import * as client from "./client.js";
import type { BoxEndpoint, BoxListener } from "./client.js";
import { BOX_PORT, type BoxLog } from "./common.js";

export const PORT_POLL_MS = 2_000;
export const PORT_MIN = 1024;
export const PORT_MAX = 65535;
/** At most this many forwards at once (a box listening on hundreds of ports is not a dev server). */
export const PORT_FORWARDS_MAX = 32;

/** The one line a forward's opening is told with. */
export function portLine(port: number): string {
  return `Port ${port} in the sandbox is open on this computer at http://127.0.0.1:${port}`;
}

/** Whether a box listener is one to forward (`skip`: ports never forwarded). */
export function forwardable(port: number, skip: Set<number> = new Set([BOX_PORT])): boolean {
  return Number.isInteger(port) && port >= PORT_MIN && port <= PORT_MAX && !skip.has(port);
}

/** Whether something on this computer answers at 127.0.0.1:<port>. */
export function hostAnswers(port: number, { timeoutMs = 300 }: { timeoutMs?: number } = {}): Promise<boolean> {
  return new Promise((resolve) => {
    const socket = net.connect({ host: "127.0.0.1", port });
    const done = (value: boolean) => { clearTimeout(timer); socket.destroy(); resolve(value); };
    const timer = setTimeout(() => done(false), timeoutMs);
    socket.once("connect", () => done(true));
    socket.once("error", () => done(false));
  });
}

/** Listen on 127.0.0.1:<port> (only there); resolves the server, or null when the port is taken. */
export function listenLoopback(port: number, onConnection: (socket: net.Socket) => void): Promise<net.Server | null> {
  return new Promise((resolve) => {
    const server = net.createServer({ allowHalfOpen: true, pauseOnConnect: true }, onConnection);
    const onError = () => { server.close(); resolve(null); };
    server.once("error", onError);
    server.listen({ host: "127.0.0.1", port, exclusive: true }, () => {
      server.removeListener("error", onError);
      server.on("error", () => {});
      server.unref();
      resolve(server);
    });
  });
}

/** Join a connection on this computer to a boxd stream: both ways, each end half-closing the other. */
export function joinStreams(local: net.Socket, remote: net.Socket, head: Buffer = Buffer.alloc(0)): void {
  const both = () => { local.destroy(); remote.destroy(); };
  local.on("error", both);
  remote.on("error", both);
  local.on("close", () => remote.destroy());
  remote.on("close", () => { if (!local.destroyed) local.end(); });
  if (head.length) local.write(head);
  remote.pipe(local);
  local.pipe(remote);
  local.resume();
  remote.resume();
}

export type PortForwards = { tick: () => Promise<void>; ports: () => number[]; close: () => void };

export type PortForwardOptions = {
  /** boxd's address now; null while the box is not usable. */
  endpoint: () => BoxEndpoint | null;
  log?: BoxLog;
  onOpen?: (port: number, line: string) => void;
  onClose?: (port: number, why: string) => void;
  pollMs?: number;
  skip?: Set<number>;
  max?: number;
  list?: (endpoint: BoxEndpoint) => Promise<BoxListener[] | null>;
  connect?: (endpoint: BoxEndpoint, port: number) => Promise<{ socket: net.Socket; head: Buffer }>;
  hostBusy?: (port: number) => Promise<boolean>;
  listen?: (port: number, onConnection: (socket: net.Socket) => void) => Promise<net.Server | null>;
  /** Poll on its own (false: only tick(), tests). */
  timers?: boolean;
};

/** The forwards of one project's box; the poll runs until close(). */
export function portForwards({
  endpoint,
  log = () => {},
  onOpen = () => {},
  onClose = () => {},
  pollMs = PORT_POLL_MS,
  skip = new Set([BOX_PORT]),
  max = PORT_FORWARDS_MAX,
  list = (ep) => client.listPorts(ep),
  connect = (ep, port) => client.connectPort(ep, port),
  hostBusy = (port) => hostAnswers(port),
  listen = listenLoopback,
  timers = true,
}: PortForwardOptions): PortForwards {
  const forwards = new Map<number, { server: net.Server; sockets: Set<net.Socket> }>();
  const told = new Set<number>(); // ports already said to be taken here (said once)
  let closed = false;
  let running: Promise<void> | null = null;
  let unsupported = false;
  let timer: ReturnType<typeof setInterval> | null = null;

  const shut = (port: number, why: string) => {
    const forward = forwards.get(port);
    if (!forward) return;
    forwards.delete(port);
    forward.server.close();
    for (const socket of forward.sockets) socket.destroy();
    log("info", "box port forward closed", { port, why });
    onClose(port, why);
  };

  const taken = (port: number) => {
    if (told.has(port)) return;
    told.add(port);
    log("info", "box port not forwarded: in use on this computer", { port });
  };

  const open = async (port: number) => {
    // Something of this computer's own answers there: it stays this computer's.
    if (await hostBusy(port)) return taken(port);
    const sockets = new Set<net.Socket>();
    const server = await listen(port, (local) => {
      sockets.add(local);
      local.on("close", () => sockets.delete(local));
      const ep = endpoint();
      if (!ep) { local.destroy(); return; }
      connect(ep, port).then(({ socket, head }) => {
        if (local.destroyed || closed) { socket.destroy(); return; }
        sockets.add(socket);
        socket.on("close", () => sockets.delete(socket));
        joinStreams(local, socket, head);
      }, (error: unknown) => {
        log("info", "box port connection failed", { port, error: error instanceof Error ? error.message : String(error) });
        local.destroy();
      });
    });
    if (!server) return taken(port);
    if (closed) { server.close(); return; }
    told.delete(port);
    forwards.set(port, { server, sockets });
    log("info", "box port forwarded", { port, line: portLine(port) });
    onOpen(port, portLine(port));
  };

  const once = async () => {
    const ep = endpoint();
    if (!ep || unsupported) return;
    let listening: BoxListener[] | null;
    try {
      listening = await list(ep);
    } catch {
      return; // the box does not answer now (stopped, restarting): the forwards stay until it says otherwise
    }
    if (listening === null) {
      unsupported = true;
      log("info", "box ports not forwarded: this sandbox was made by an older version (Reset sandbox gives it the new helper)");
      return;
    }
    const wanted = new Set(listening.map((item) => item.port).filter((port) => forwardable(port, skip)));
    for (const port of [...forwards.keys()]) if (!wanted.has(port)) shut(port, "gone");
    for (const port of [...wanted].sort((a, b) => a - b)) {
      if (closed) return;
      if (forwards.has(port)) continue;
      if (forwards.size >= max) break;
      await open(port);
    }
  };

  const tick = (): Promise<void> => {
    if (closed) return Promise.resolve();
    running ??= once()
      .catch((error: unknown) => log("warn", "box port forwards failed", { error: error instanceof Error ? error.message : String(error) }))
      .finally(() => { running = null; });
    return running;
  };

  if (timers) {
    timer = setInterval(() => { void tick(); }, pollMs);
    timer.unref?.();
    void tick();
  }

  return {
    tick,
    ports: () => [...forwards.keys()].sort((a, b) => a - b),
    close() {
      if (closed) return;
      closed = true;
      if (timer) clearInterval(timer);
      for (const port of [...forwards.keys()]) shut(port, "ended");
    },
  };
}