Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
import { describe, expect, test } from "bun:test";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import { createServer, type Socket } from "node:net";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
BunWebSocket,
fileFor,
isApiCall,
isClientRoute,
upstreamWebSocketHeaders,
} from "../serve";
async function probeServingPorts(env: {
APP_PORT?: string;
SERVER_PORT?: string;
}) {
const directory = await mkdtemp(join(tmpdir(), "openbot-serve-ports-"));
const preload = join(directory, "probe.mjs");
try {
// Run the real entry and API handler, stopping both boundaries before any network access.
// This also exercises privileged/default ports without binding or contacting those services.
await writeFile(
preload,
`globalThis.fetch = async (target) => Response.json({ target });
Bun.serve = (options) => {
Promise.resolve(options.fetch(new Request("http://localhost/api/port-check"), {}))
.then((response) => response.json())
.then(({ target }) => {
console.log("PORT_PROBE:" + JSON.stringify({ port: options.port, target }));
process.exit(0);
}).catch((error) => { console.error(error); process.exit(1); });
};
`,
);
const child = Bun.spawn({
cmd: [
process.execPath,
"--no-env-file",
"--preload",
preload,
"serve.ts",
],
cwd: join(import.meta.dir, ".."),
env,
stdout: "pipe",
stderr: "pipe",
});
const timeout = setTimeout(() => child.kill(), 2_000);
try {
const [exitCode, stdout, stderr] = await Promise.all([
child.exited,
new Response(child.stdout).text(),
new Response(child.stderr).text(),
]);
return { exitCode, stdout, stderr };
} finally {
clearTimeout(timeout);
child.kill();
await child.exited;
}
} finally {
await rm(directory, { recursive: true, force: true });
}
}
describe("serving port configuration", () => {
test.each([undefined, "", " \t "])(
"absent or blank ports use the app and server defaults: %j",
async (raw) => {
const result = await probeServingPorts({
APP_PORT: raw,
SERVER_PORT: raw,
});
expect(result.exitCode).toBe(0);
expect(result.stdout).toContain(
'PORT_PROBE:{"port":3010,"target":"http://127.0.0.1:3001/api/port-check"}',
);
expect(result.stdout).toContain("OpenBot app on http://127.0.0.1:3010");
},
);
test.each(["1", "65535", " 43123 "])(
"accepts whole ports including both bounds and surrounding whitespace: %j",
async (raw) => {
const result = await probeServingPorts({
APP_PORT: raw,
SERVER_PORT: raw,
});
expect(result.exitCode).toBe(0);
expect(result.stdout).toContain(
`PORT_PROBE:${JSON.stringify({
port: Number(raw),
target: `http://127.0.0.1:${Number(raw)}/api/port-check`,
})}`,
);
},
);
for (const name of ["APP_PORT", "SERVER_PORT"] as const) {
test.each(["3010oops", "0", "-1", "65536", "1.5", "1e3"])(
`${name} refuses invalid ports before serving: %j`,
async (raw) => {
const result = await probeServingPorts({ [name]: raw });
expect(result.exitCode).not.toBe(0);
expect(result.stderr).toContain(
`${name} must be a whole number from 1 to 65535`,
);
expect(result.stdout).not.toContain("PORT_PROBE:");
expect(result.stdout).not.toContain("OpenBot app on");
},
);
}
});
/**
* Serving the built app, which replaced `vite preview`.
*
* The failure that made this necessary: `vite preview` under `bun --bun` dies on the first proxied
* call with `TypeError: socket.destroySoon is not a function`, so the app served its page, exited,
* and the shell's window went on saying "OpenBot is running" with nothing listening.
*/
describe("what answers a request", () => {
test("the server answers its own prefix, and nothing near it", () => {
expect(isApiCall("/api")).toBe(true);
expect(isApiCall("/api/channels")).toBe(true);
// Not the app's own routes, and not a path that merely starts with the same letters.
expect(isApiCall("/apixyz")).toBe(false);
expect(isApiCall("/channel/api")).toBe(false);
expect(isApiCall("/")).toBe(false);
});
/**
* A miss under `/assets` is a real 404. Answering index.html there hands a script tag some HTML,
* which fails in the console rather than in the network panel and reads as a broken app.
*/
test("a missing built file is not answered with the page", () => {
expect(isClientRoute("/assets/index-abc123.js")).toBe(false);
expect(isClientRoute("/favicon.ico")).toBe(false);
});
/** Every other miss is the app's own router: /channel/<id> has to load the page. */
test("a client route is answered with the page", () => {
expect(isClientRoute("/channel/channel_1ed78a89")).toBe(true);
expect(isClientRoute("/agents")).toBe(true);
expect(isClientRoute("/")).toBe(true);
});
});
describe("which file a path names", () => {
test("the root and any directory are the page", () => {
expect(fileFor("/")).toEndWith(join("/dist/index.html"));
expect(fileFor("/channel/")).toEndWith(join("/dist/index.html"));
});
test("a built asset is itself", () => {
expect(fileFor("/assets/index-abc.js")).toEndWith(
join("/dist/assets/index-abc.js"),
);
});
test("an encoded asset remains inside the static directory", () => {
expect(fileFor("/assets/hello%20world.js")).toEndWith(
join("/dist/assets/hello world.js"),
);
expect(fileFor("/assets/caf%C3%A9%25.js")).toEndWith(
join("/dist/assets/café%.js"),
);
});
test.each([
"/%",
"/%E0%A4%A",
"/%FF",
"/%C0%AF",
"/%ED%A0%80",
"/%F4%90%80%80",
"/assets/bad%.js",
])("a malformed encoded path is refused: %s", (pathname) => {
expect(fileFor(pathname)).toBeNull();
});
test("a decoded NUL path is refused before it reaches Bun.file", async () => {
const proxy = await startProxy(await unusedPort());
try {
const response = await fetch(
`http://127.0.0.1:${proxy.port}/assets/a%00b.js`,
);
expect(response.status).toBe(404);
expect(await response.text()).toBe("not found");
} finally {
await proxy.stop();
}
expect(fileFor("/assets/a%00b.js")).toBeNull();
});
test("only decoded NUL is refused by the invalid-path guard", () => {
expect(fileFor("/assets/a%1Fb.js")).toEndWith(join("/dist/assets/ab.js"));
});
test("a client route remains available for the router", () => {
expect(fileFor("/channel/channel_1ed78a89")).toEndWith(
join("/dist/channel/channel_1ed78a89"),
);
});
test.each(["/../dist2/file", "/../dist-secret", "/../dist-curation/"])(
"a prefix sibling is refused: %s",
(pathname) => {
expect(fileFor(pathname)).toBeNull();
},
);
test.each([
"/%2e%2e%2fdist-curation/token.txt",
"/%2e%2e%2fdist2/file",
"/assets/%2e%2e%2f%2e%2e%2fdist-secret",
])("an encoded separator cannot reach a prefix sibling: %s", (pathname) => {
expect(fileFor(pathname)).toBeNull();
});
/**
* Nothing outside the directory, whatever the request says. This server has the deployment's
* `.env` two levels above it, so the traversal guard is not theoretical.
*/
test("a path that climbs out is refused", () => {
expect(fileFor("/../.env")).toBeNull();
expect(fileFor("/../../.env")).toBeNull();
expect(fileFor("/%2e%2e/%2e%2e/.env")).toBeNull();
expect(fileFor("/assets/../../.env")).toBeNull();
});
});
type HeaderSnapshot = {
authorization: string | null;
cookie: string | null;
origin: string | null;
};
async function unusedPort(): Promise<number> {
return new Promise((resolve, reject) => {
const server = createServer();
server.on("error", reject);
server.listen(0, "127.0.0.1", () => {
const address = server.address();
server.close(() => {
if (address && typeof address === "object") {
resolve(address.port);
} else {
reject(new Error("server did not receive a TCP port"));
}
});
});
});
}
function snapshotHeaders(request: Request): HeaderSnapshot {
return {
authorization: request.headers.get("authorization"),
cookie: request.headers.get("cookie"),
origin: request.headers.get("origin"),
};
}
function startAuthenticatedUpstream(port: number) {
const webSocketHandshakes: HeaderSnapshot[] = [];
const server = Bun.serve({
port,
hostname: "127.0.0.1",
fetch(request, server) {
if (request.headers.get("upgrade")?.toLowerCase() === "websocket") {
const headers = snapshotHeaders(request);
webSocketHandshakes.push(headers);
if (headers.cookie !== "openbot_session=valid") {
return new Response("Sign in first.", { status: 401 });
}
if (server.upgrade(request)) return undefined;
}
if (new URL(request.url).pathname === "/api/header-check") {
return Response.json(snapshotHeaders(request));
}
return new Response("not found", { status: 404 });
},
websocket: {
message(ws, message) {
ws.send(`echo:${message}`);
},
},
});
return { server, webSocketHandshakes };
}
async function waitForProxy(port: number) {
const deadline = Date.now() + 2_000;
while (Date.now() < deadline) {
try {
const response = await fetch(
`http://127.0.0.1:${port}/assets/proxy-readiness`,
);
if (response.status === 404) return;
} catch {
await Bun.sleep(25);
}
}
throw new Error("proxy did not start");
}
async function startProxy(upstreamPort: number) {
const port = await unusedPort();
const child = Bun.spawn({
cmd: [process.execPath, "--no-env-file", "serve.ts"],
cwd: join(import.meta.dir, ".."),
env: { APP_PORT: String(port), SERVER_PORT: String(upstreamPort) },
stdout: "pipe",
stderr: "pipe",
});
try {
await waitForProxy(port);
} catch (error) {
child.kill();
await child.exited;
throw error;
}
return {
port,
async stop() {
child.kill();
await child.exited;
},
};
}
test.each([
["dictation", "/api/audio/transcriptions", "x-openbot-dictation"],
["voice", "/api/voice/calls", "x-openbot-voice"],
])(
"%s can wait for a provider past Bun's default idle timeout",
async (_name, path, header) => {
const upstream = Bun.serve({
port: 0,
hostname: "127.0.0.1",
idleTimeout: 70,
async fetch() {
await Bun.sleep(13_000);
return Response.json({ text: "A slower transcription" });
},
});
if (upstream.port === undefined) {
upstream.stop(true);
throw new Error("The test upstream did not bind a TCP port");
}
const proxy = await startProxy(upstream.port);
try {
const response = await fetch(`http://127.0.0.1:${proxy.port}${path}`, {
method: "POST",
headers: { [header]: "1" },
signal: AbortSignal.timeout(18_000),
});
expect(response.status).toBe(200);
expect(await response.json()).toEqual({ text: "A slower transcription" });
} finally {
await proxy.stop();
upstream.stop(true);
}
},
20_000,
);
async function failedHandshake(url: string, headers: HeadersInit = {}) {
const events: string[] = [];
const socket = new BunWebSocket(url, { headers });
try {
await new Promise<void>((resolve, reject) => {
const timeout = setTimeout(
() => reject(new Error("handshake stayed pending")),
7_000,
);
socket.onopen = () => events.push("open");
socket.onerror = () => events.push("error");
socket.onclose = () => {
events.push("close");
clearTimeout(timeout);
resolve();
};
});
return events;
} finally {
socket.terminate();
}
}
async function connectWebSocket(url: string, headers: HeadersInit) {
return new Promise<BunWebSocket>((resolve, reject) => {
const socket = new BunWebSocket(url, { headers });
const timeout = setTimeout(() => {
socket.close();
reject(new Error("websocket did not open"));
}, 1_000);
socket.addEventListener(
"open",
() => {
clearTimeout(timeout);
resolve(socket);
},
{ once: true },
);
socket.addEventListener(
"error",
() => {
clearTimeout(timeout);
reject(new Error("websocket failed before opening"));
},
{ once: true },
);
});
}
async function nextSocketMessage(socket: BunWebSocket) {
return new Promise<string>((resolve, reject) => {
const timeout = setTimeout(() => {
socket.close();
reject(new Error("websocket message timed out"));
}, 1_000);
socket.addEventListener(
"message",
(event) => {
clearTimeout(timeout);
resolve(String(event.data));
},
{ once: true },
);
});
}
async function waitForHandshake(
handshakes: HeaderSnapshot[],
count: number,
): Promise<HeaderSnapshot> {
const deadline = Date.now() + 1_000;
while (Date.now() < deadline) {
const handshake = handshakes.at(count - 1);
if (handshake) return handshake;
await Bun.sleep(10);
}
throw new Error(`upstream saw ${handshakes.length} websocket handshakes`);
}
describe("api proxy", () => {
test("keeps upstream websocket forwarding to session and origin headers", () => {
const headers = upstreamWebSocketHeaders(
new Headers({
Authorization: "Bearer app-session",
Connection: "Upgrade",
Cookie: "openbot_session=valid",
Host: "127.0.0.1:3010",
Origin: "http://openbot.local",
"Sec-WebSocket-Key": "client-generated",
Upgrade: "websocket",
}),
);
expect(Object.fromEntries(headers)).toEqual({
authorization: "Bearer app-session",
cookie: "openbot_session=valid",
origin: "http://openbot.local",
});
});
test("forwards session headers to authenticated upstream websocket handshakes", async () => {
const upstreamPort = await unusedPort();
const upstream = startAuthenticatedUpstream(upstreamPort);
const proxy = await startProxy(upstreamPort);
const proxyPort = proxy.port;
try {
const sessionHeaders = {
Authorization: "Bearer app-session",
Cookie: "openbot_session=valid",
Origin: "http://openbot.local",
};
const httpResponse = await fetch(
`http://127.0.0.1:${proxyPort}/api/header-check`,
{ headers: sessionHeaders },
);
expect(await httpResponse.json()).toEqual({
authorization: "Bearer app-session",
cookie: "openbot_session=valid",
origin: "http://openbot.local",
});
const unauthorizedEvents = await failedHandshake(
`ws://127.0.0.1:${proxyPort}/api/header-check`,
{
Authorization: "Bearer app-session",
Origin: "http://openbot.local",
},
);
const unauthorizedHandshake = await waitForHandshake(
upstream.webSocketHandshakes,
1,
);
expect(unauthorizedEvents).toEqual(["error", "close"]);
expect(unauthorizedHandshake).toEqual({
authorization: "Bearer app-session",
cookie: null,
origin: "http://openbot.local",
});
const socket = await connectWebSocket(
`ws://127.0.0.1:${proxyPort}/api/header-check`,
sessionHeaders,
);
socket.send("ping");
expect(await nextSocketMessage(socket)).toBe("echo:ping");
socket.close();
expect(await waitForHandshake(upstream.webSocketHandshakes, 2)).toEqual({
authorization: "Bearer app-session",
cookie: "openbot_session=valid",
origin: "http://openbot.local",
});
} finally {
upstream.server.stop(true);
await proxy.stop();
}
});
});
describe("upstream websocket handshake", () => {
test("an unavailable upstream never opens the downstream", async () => {
const proxy = await startProxy(await unusedPort());
try {
expect(
await failedHandshake(`ws://127.0.0.1:${proxy.port}/api/events`),
).toEqual(["error", "close"]);
} finally {
await proxy.stop();
}
});
test("a stalled handshake times out and releases its upstream TCP socket", async () => {
const sockets = new Set<Socket>();
let requests = 0;
const upstream = createServer((socket) => {
sockets.add(socket);
socket.on("data", () => requests++);
socket.on("close", () => sockets.delete(socket));
});
const port = await unusedPort();
await new Promise<void>((resolve) =>
upstream.listen(port, "127.0.0.1", resolve),
);
const proxy = await startProxy(port);
try {
const started = Date.now();
expect(
await failedHandshake(`ws://127.0.0.1:${proxy.port}/api/events`),
).toEqual(["error", "close"]);
expect(Date.now() - started).toBeLessThan(6_500);
expect(requests).toBe(1);
const deadline = Date.now() + 500;
while (sockets.size && Date.now() < deadline) await Bun.sleep(10);
expect(sockets.size).toBe(0);
} finally {
for (const socket of sockets) socket.destroy();
await new Promise<void>((resolve) => upstream.close(() => resolve()));
await proxy.stop();
}
}, 9_000);
test("a delayed upstream keeps welcome frames and the first downstream inputs in order", async () => {
let upstreamOpenedAt = 0;
const received: string[] = [];
const upstream = Bun.serve({
port: 0,
hostname: "127.0.0.1",
async fetch(request, server) {
await Bun.sleep(150);
if (server.upgrade(request)) return;
return new Response("bad upgrade", { status: 400 });
},
websocket: {
open(ws) {
upstreamOpenedAt = Date.now();
ws.send("welcome:one");
ws.send("welcome:two");
},
message(ws, message) {
received.push(String(message));
ws.send(`echo:${message}`);
},
},
});
const proxy = await startProxy(upstream.port!);
const socket = new BunWebSocket(
`ws://127.0.0.1:${proxy.port}/api/events?mode=delayed`,
);
try {
const messages: string[] = [];
let downstreamOpenedAfterUpstream = false;
await new Promise<void>((resolve, reject) => {
const timeout = setTimeout(
() => reject(new Error("messages did not arrive")),
2_000,
);
socket.onopen = () => {
downstreamOpenedAfterUpstream = upstreamOpenedAt > 0;
socket.send("one");
socket.send("two");
};
socket.onmessage = (event) => {
messages.push(String(event.data));
if (messages.length === 4) {
clearTimeout(timeout);
resolve();
}
};
socket.onerror = () => {
clearTimeout(timeout);
reject(new Error("healthy socket failed"));
};
});
expect(downstreamOpenedAfterUpstream).toBe(true);
expect(messages).toEqual([
"welcome:one",
"welcome:two",
"echo:one",
"echo:two",
]);
expect(received).toEqual(["one", "two"]);
} finally {
socket.terminate();
upstream.stop(true);
await proxy.stop();
}
});
});