Skip to content

A personal agent with a browser, terminal, files, and work that keeps going built with CopilotKit and AG-UI.

TypeScript
29.4 KB
Raw Blame
import assert from "node:assert/strict";
import { once } from "node:events";
import { mkdir, mkdtemp, readFile, rm, symlink, truncate, writeFile } from "node:fs/promises";
import { request } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { Readable } from "node:stream";
import test from "node:test";
import { createApp } from "../apps/server/src/app.ts";
import { Auth } from "../apps/server/src/auth.ts";
import { BrowserService } from "../apps/server/src/browser.ts";
import { Files } from "../apps/server/src/files.ts";
import { capturePdfDownload, readDownloadFailures } from "../apps/worker/src/downloads.ts";
import { isPublicIp, validatePublicUrl } from "../apps/worker/src/network.ts";
import { startEgressProxy } from "../apps/worker/src/proxy.ts";
import { createWorkerServer } from "../apps/worker/src/server.ts";
import type { BrowserSession } from "../packages/domain/src/index.ts";
import { browserFixture } from "./helpers/browser.ts";

const sessionId = "00000000-0000-4000-8000-000000000001";
const savedSession: BrowserSession = {
  id: sessionId,
  title: "Saved page",
  url: "https://example.com/",
  status: "active",
  updatedAt: "2026-09-15T00:00:00.000Z",
};

test("browser API reopens an owned profile at the edited address and renews console access", async (t) => {
  const calls: { path: string; body: Record<string, unknown> }[] = [];
  const { db, config } = await browserFixture(t, (path, body) => {
    calls.push({ path, body });
    return { data: { ...savedSession, url: body.url } };
  });
  const { app, auth, agent } = await createApp(db, config);
  t.after(() => agent.stop());
  const { token } = await auth.session();
  const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
  await db.put("local-user", "browsers", { ...savedSession, status: "closed" });
  const path = `/api/browsers/${sessionId}`;
  const opened = await app.request(`${path}/reopen`, {
    method: "POST",
    headers,
    body: JSON.stringify({ url: "https://example.org/" }),
  });
  assert.equal(opened.status, 200);
  assert.equal((await opened.json()).url, "https://example.org/");
  assert.deepEqual(calls[0], {
    path: "/sessions",
    body: { id: sessionId, url: "https://example.org/" },
  });
  assert.equal((await app.request(`${path}/reopen`, { method: "POST", headers })).status, 200);
  assert.equal(
    calls[1]?.body.url,
    "https://example.org/",
    "bodyless reopen keeps the saved address",
  );

  const start = Date.now();
  const clock = t.mock.method(Date, "now", () => start);
  const previous: BrowserSession = await (await app.request(path, { headers })).json();
  assert.ok(previous.consoleUrl);
  clock.mock.mockImplementation(() => start + 16 * 60_000);
  assert.equal((await app.request(previous.consoleUrl)).status, 401);
  const renewed: BrowserSession = await (await app.request(path, { headers })).json();
  assert.ok(renewed.consoleUrl);
  assert.notEqual(renewed.consoleUrl, previous.consoleUrl);
  const console = await app.request(renewed.consoleUrl);
  assert.equal(console.status, 200);
  assert.match(await console.text(), /Text to type in browser/);
  assert.equal((await app.request(path)).status, 401);
  const hiddenId = "00000000-0000-4000-8000-000000000099";
  await db.put("someone-else", "browsers", { ...savedSession, id: hiddenId });
  assert.equal((await app.request(`/api/browsers/${hiddenId}`, { headers })).status, 404);
  assert.equal(
    (await app.request(`/api/browsers/${hiddenId}/reopen`, { method: "POST", headers, body: "{}" }))
      .status,
    404,
  );
  assert.equal(calls.length, 2, "renewal and rejected requests never navigate the browser");
});

test("server reopens the same worker UUID regardless of stale local session status", async (t) => {
  const calls: { path: string; body: Record<string, unknown> }[] = [];
  const { db, service } = await browserFixture(t, (path, body) => {
    calls.push({ path, body });
    return { data: { ...savedSession, url: body.url } };
  });
  for (const status of ["active", "closed", "idle", "error"] as const) {
    await db.put("owner", "browsers", { ...savedSession, status });
    const opened = await service.navigate("owner", sessionId, "https://example.org/");
    assert.equal(opened.id, sessionId);
    assert.deepEqual(calls.at(-1), {
      path: "/sessions",
      body: { id: sessionId, url: "https://example.org/" },
    });
    assert.equal((await service.get("owner", sessionId)).url, "https://example.org/");
  }
  await assert.rejects(service.navigate("stranger", sessionId, "https://example.org/"), {
    status: 404,
  });
  assert.equal(calls.length, 4);
});

test("console input persists the worker's current page title and URL", async (t) => {
  const updated = { ...savedSession, title: "New page", url: "https://example.org/" };
  const { db, service } = await browserFixture(t, () => ({ data: updated }));
  await db.put("owner", "browsers", savedSession);
  const result = await service.input("owner", sessionId, { type: "key", key: "Enter" });
  assert.equal(result.title, updated.title);
  assert.deepEqual(await service.get("owner", sessionId), updated);
});

test("failed creation remains app-visible and can be retried with its original UUID", async (t) => {
  let failing = true;
  let requestedId: unknown;
  const { db, service } = await browserFixture(t, (_path, body) => {
    requestedId = body.id;
    return failing
      ? { status: 502, data: { error: { code: "NAVIGATION_FAILED", message: "Page unavailable" } } }
      : { data: { ...savedSession, id: body.id, url: body.url } };
  });
  await assert.rejects(service.create("owner", "https://example.org/"), /Page unavailable/);
  const sessions = await db.list<BrowserSession>("owner", "browsers");
  assert.equal(sessions.length, 1);
  assert.equal(sessions[0]?.id, requestedId);
  assert.equal(sessions[0]?.status, "error");
  assert.equal(sessions[0]?.url, "https://example.org/");
  failing = false;
  const result = await service.reopen("owner", sessions[0].id);
  assert.equal(result.id, sessions[0]?.id);
  assert.equal(result.status, "active");
});

test("browser observations reuse an owned profile and reject unowned reads", async (t) => {
  const calls: string[] = [];
  const read = {
    url: "https://example.org/",
    title: "Observed",
    text: "Public page text",
    truncated: false,
  };
  const { db, service } = await browserFixture(t, (path, body) => {
    calls.push(path);
    return {
      data: path.endsWith("/read") ? read : { ...savedSession, id: body.id, url: body.url },
    };
  });
  await db.put("owner", "browsers", savedSession);
  assert.deepEqual(await service.observe("owner", read.url, sessionId), { sessionId, ...read });
  assert.deepEqual(calls, ["/sessions", `/sessions/${sessionId}/read`]);
  assert.equal((await service.get("owner", sessionId)).title, read.title);
  await assert.rejects(service.read("stranger", sessionId), { status: 404 });
  await assert.rejects(service.observe("stranger", read.url, sessionId), { status: 404 });
  assert.equal(calls.length, 2);
  const fresh = await service.observe("owner", read.url);
  assert.notEqual(fresh.sessionId, sessionId);
  assert.equal(fresh.text, read.text);
});

test("cancelled task-style browser observations stop before a follow-up read", async (t) => {
  const controller = new AbortController();
  const calls: string[] = [];
  const { db, service } = await browserFixture(t, (path, body) => {
    calls.push(path);
    controller.abort();
    return { data: { ...savedSession, id: body.id, url: body.url } };
  });
  await assert.rejects(service.observe("owner", savedSession.url, undefined, controller.signal), {
    name: "AbortError",
  });
  assert.deepEqual(calls, ["/sessions"]);
  const [saved] = await db.list<BrowserSession>("owner", "browsers");
  assert.equal(saved?.status, "idle", "cancellation must not persist a browser failure");
});

test("chat browser reads reuse a persisted owned profile across turns and service restarts", async (t) => {
  const calls: { path: string; body: Record<string, unknown> }[] = [];
  let currentUrl = savedSession.url;
  const { db, service, config } = await browserFixture(t, (path, body) => {
    calls.push({ path, body });
    if (path.endsWith("/read"))
      return {
        data: { url: currentUrl, title: "Read page", text: "x".repeat(30_001), truncated: false },
      };
    currentUrl = String(body.url);
    return { data: { ...savedSession, id: body.id, url: currentUrl } };
  });
  const first = await service.observeForThread("owner", "chat-thread", "https://example.org/first");
  assert.equal(first.text.length, 30_000);
  assert.equal(first.truncated, true);
  const auth = new Auth(db, config, "test-signing-key");
  const restarted = new BrowserService(db, config, auth, new Files(db, config, auth));
  for (const status of ["active", "closed", "error", "idle"] as const) {
    await db.put("owner", "browsers", { ...(await service.get("owner", first.sessionId)), status });
    const next = await restarted.observeForThread(
      "owner",
      "chat-thread",
      `https://example.org/${status}`,
    );
    assert.equal(next.sessionId, first.sessionId);
    assert.equal(next.url, `https://example.org/${status}`);
  }
  assert.equal((await db.list("owner", "browsers")).length, 1);
  assert.equal(calls.filter((call) => call.path === "/sessions").length, 5);
  const otherOwner = await restarted.observeForThread("stranger", "chat-thread", savedSession.url);
  assert.notEqual(otherOwner.sessionId, first.sessionId);
  await assert.rejects(restarted.get("stranger", first.sessionId), { status: 404 });
});

test("chat browser retries failed navigation using the reserved profile", async (t) => {
  const ids: unknown[] = [];
  let failing = true;
  const { db, service } = await browserFixture(t, (path, body) => {
    if (path.endsWith("/read"))
      return {
        data: {
          url: savedSession.url,
          title: "Read page",
          text: "Actual contents",
          truncated: true,
        },
      };
    ids.push(body.id);
    return failing
      ? { status: 502, data: { error: { message: "Page unavailable" } } }
      : { data: { ...savedSession, id: body.id } };
  });
  await assert.rejects(
    service.observeForThread("owner", "chat-thread", savedSession.url),
    /Page unavailable/,
  );
  assert.equal((await db.list<BrowserSession>("owner", "browsers"))[0]?.status, "error");
  failing = false;
  const result = await service.observeForThread("owner", "chat-thread", savedSession.url);
  assert.deepEqual(ids, [result.sessionId, result.sessionId]);
  assert.equal(result.text, "Actual contents");
  assert.equal(result.truncated, true);
});

test("concurrent chat reads keep each navigation paired with its page read", async (t) => {
  let currentUrl = savedSession.url;
  const { db, service } = await browserFixture(t, (path, body) => {
    if (path.endsWith("/read"))
      return { data: { url: currentUrl, title: currentUrl, text: currentUrl, truncated: false } };
    currentUrl = String(body.url);
    return { data: { ...savedSession, id: body.id, url: currentUrl } };
  });
  const urls = ["https://example.org/one", "https://example.org/two"];
  const results = await Promise.all(
    urls.map((url) => service.observeForThread("owner", "chat-thread", url)),
  );
  assert.deepEqual(
    results.map((result) => result.text),
    urls,
  );
  assert.equal(results[0].sessionId, results[1].sessionId);
  assert.equal((await db.list("owner", "browsers")).length, 1);
});

test("cancelled chat browser requests do not start navigation or a follow-up read", async (t) => {
  const controller = new AbortController();
  const calls: string[] = [];
  const { db, service } = await browserFixture(t, (path, body) => {
    calls.push(path);
    controller.abort();
    return { data: { ...savedSession, id: body.id } };
  });
  await assert.rejects(
    service.observeForThread("owner", "chat-thread", savedSession.url, controller.signal),
    { name: "AbortError" },
  );
  assert.deepEqual(calls, ["/sessions"]);
  await assert.rejects(
    service.observeForThread("owner", "other-thread", savedSession.url, controller.signal),
    { name: "AbortError" },
  );
  assert.deepEqual(calls, ["/sessions"]);
  assert.equal((await db.list("owner", "browsers")).length, 1);
});

test("browser read fails on missing page text instead of inventing observation content", async (t) => {
  const { db, service } = await browserFixture(t, () => ({
    data: { url: savedSession.url, title: savedSession.title },
  }));
  await db.put("owner", "browsers", savedSession);
  await assert.rejects(service.read("owner", sessionId));
});

test("browser imports return rejected downloads even when no PDF was accepted", async (t) => {
  const failure = {
    id: "00000000-0000-4000-8000-000000000005",
    name: "oversized.pdf",
    code: "DOWNLOAD_TOO_LARGE",
    message: "The download exceeds 10 MiB.",
    createdAt: "2026-09-15T00:00:00.000Z",
  };
  const { db, service } = await browserFixture(t, () => ({
    data: { downloads: [], failures: [failure] },
  }));
  await db.put("owner", "browsers", savedSession);
  assert.deepEqual(await service.imports("owner", sessionId), { files: [], failures: [failure] });
});

test("worker persists unsupported, oversized and interrupted download outcomes", async () => {
  const directory = await mkdtemp(join(tmpdir(), "openmuse-download-outcomes-"));
  try {
    const cases = [
      { name: "notes.txt", contents: Buffer.from("not a PDF"), code: "UNSUPPORTED_DOWNLOAD" },
      {
        name: "large.pdf",
        contents: Buffer.alloc(10 * 1024 * 1024 + 1),
        code: "DOWNLOAD_TOO_LARGE",
      },
      { name: "cancelled.pdf", contents: null, code: "DOWNLOAD_INTERRUPTED" },
    ];
    for (const item of cases) {
      await capturePdfDownload({
        directory,
        tempDirectory: directory,
        limitReached: false,
        download: {
          suggestedFilename: () => item.name,
          createReadStream: async () => {
            if (!item.contents) throw new Error("Interrupted download");
            return Readable.from([item.contents]);
          },
          cancel: async () => {},
          delete: async () => {},
        },
      });
    }
    const failures = await readDownloadFailures(directory);
    assert.equal(failures.length, 3);
    for (const item of cases) {
      assert.equal(failures.find((failure) => failure.name === item.name)?.code, item.code);
    }
    assert(failures.every((failure) => failure.message && failure.createdAt));
  } finally {
    await rm(directory, { recursive: true, force: true });
  }
});

test("worker recovery cleans unpublished downloads and retains their interruption failures", async (t) => {
  const directory = await mkdtemp(join(tmpdir(), "openmuse-download-recovery-"));
  t.after(() => rm(directory, { recursive: true, force: true }));
  const folder = join(directory, "downloads");
  const outcomes = join(directory, "download-outcomes");
  await mkdir(folder);
  await mkdir(outcomes);
  const failure = {
    id: "00000000-0000-4000-8000-000000000006",
    name: "unfinished.pdf",
    code: "DOWNLOAD_INTERRUPTED",
    message: "The download was interrupted.",
    createdAt: "2026-09-15T00:00:00.000Z",
  };
  const pdf = join(folder, `${failure.id}.pdf`);
  const metadataTemp = join(folder, `${failure.id}.json.tmp`);
  const bytes = Buffer.from("%PDF-1.7\npartial download");
  await writeFile(pdf, bytes);
  await writeFile(metadataTemp, '{"id":');
  await writeFile(
    join(outcomes, `${failure.id}.json`),
    JSON.stringify({ ...failure, status: "pending" }),
  );

  assert.deepEqual(await readDownloadFailures(directory), []);
  assert.deepEqual(await readFile(pdf), bytes, "ordinary reads must not clean active downloads");
  assert.deepEqual(await readDownloadFailures(directory, true), [failure]);
  await assert.rejects(readFile(pdf), { code: "ENOENT" });
  await assert.rejects(readFile(metadataTemp), { code: "ENOENT" });
  assert.deepEqual(await readDownloadFailures(directory, true), [failure]);
});

test("worker recovery retries incomplete cleanup before recording failure", async (t) => {
  const directory = await mkdtemp(join(tmpdir(), "openmuse-download-recovery-"));
  t.after(() => rm(directory, { recursive: true, force: true }));
  const folder = join(directory, "downloads");
  const outcomes = join(directory, "download-outcomes");
  await mkdir(folder);
  await mkdir(outcomes);
  const failure = {
    id: "00000000-0000-4000-8000-000000000009",
    name: "unfinished.pdf",
    code: "DOWNLOAD_INTERRUPTED",
    message: "The download was interrupted.",
    createdAt: "2026-09-15T00:00:00.000Z",
  };
  const journal = join(outcomes, `${failure.id}.json`);
  await writeFile(journal, JSON.stringify({ ...failure, status: "pending" }));
  const pdf = join(folder, `${failure.id}.pdf`);
  await writeFile(pdf, "%PDF-1.7\npartial download");
  const metadataTemp = join(folder, `${failure.id}.json.tmp`);
  // A directory at the file path forces cleanup to fail without permission mocks.
  await mkdir(metadataTemp);

  await assert.rejects(readDownloadFailures(directory, true));
  assert.deepEqual(JSON.parse(await readFile(journal, "utf8")), { ...failure, status: "pending" });
  await assert.rejects(readFile(pdf), { code: "ENOENT" });
  await rm(metadataTemp, { recursive: true });
  assert.deepEqual(await readDownloadFailures(directory, true), [failure]);
  assert.deepEqual(await readDownloadFailures(directory, true), [failure]);
  assert.equal(JSON.parse(await readFile(journal, "utf8")).status, "failed");
});

test("worker recovery preserves downloads when metadata cannot be inspected", async (t) => {
  const directory = await mkdtemp(join(tmpdir(), "openmuse-download-recovery-"));
  t.after(() => rm(directory, { recursive: true, force: true }));
  const folder = join(directory, "downloads");
  const outcomes = join(directory, "download-outcomes");
  await mkdir(folder);
  await mkdir(outcomes);
  const id = "00000000-0000-4000-8000-000000000007";
  const outcome = {
    id,
    name: "unreadable.pdf",
    status: "pending",
    code: "DOWNLOAD_INTERRUPTED",
    message: "The download was interrupted.",
    createdAt: "2026-09-15T00:00:00.000Z",
  };
  const pdf = join(folder, `${id}.pdf`);
  const metadata = join(folder, `${id}.json`);
  const bytes = Buffer.from("%PDF-1.7\npreserve me");
  await writeFile(pdf, bytes);
  await writeFile(`${metadata}.tmp`, '{"id":');
  const journal = join(outcomes, `${id}.json`);
  await writeFile(journal, JSON.stringify(outcome));
  // A symlink loop raises a real filesystem error even when tests run as root.
  await symlink(`${id}.json`, metadata);

  await assert.rejects(readDownloadFailures(directory, true), { code: "ELOOP" });
  assert.deepEqual(await readFile(pdf), bytes);
  assert.equal(await readFile(`${metadata}.tmp`, "utf8"), '{"id":');
  assert.deepEqual(JSON.parse(await readFile(journal, "utf8")), outcome);
});

test("worker recovery reconciles published downloads and transfers without files", async (t) => {
  for (const published of [false, true]) {
    await t.test(
      published ? "published PDF is retained" : "missing files are tolerated",
      async (t) => {
        const directory = await mkdtemp(join(tmpdir(), "openmuse-download-recovery-"));
        t.after(() => rm(directory, { recursive: true, force: true }));
        const folder = join(directory, "downloads");
        const outcomes = join(directory, "download-outcomes");
        await mkdir(folder);
        await mkdir(outcomes);
        const failure = {
          id: "00000000-0000-4000-8000-000000000008",
          name: "report.pdf",
          code: "DOWNLOAD_INTERRUPTED",
          message: "The download was interrupted.",
          createdAt: "2026-09-15T00:00:00.000Z",
        };
        const journal = join(outcomes, `${failure.id}.json`);
        await writeFile(journal, JSON.stringify({ ...failure, status: "pending" }));
        const bytes = Buffer.from("%PDF-1.7\npublished download");
        const pdf = join(folder, `${failure.id}.pdf`);
        const metadata = join(folder, `${failure.id}.json`);
        const saved = {
          id: failure.id,
          name: failure.name,
          size: bytes.length,
          mimeType: "application/pdf",
        };
        if (published) {
          await writeFile(pdf, bytes);
          await writeFile(metadata, JSON.stringify(saved));
        }

        const expected = published ? [] : [failure];
        assert.deepEqual(await readDownloadFailures(directory, true), expected);
        assert.deepEqual(await readDownloadFailures(directory, true), expected);
        if (published) {
          assert.deepEqual(await readFile(pdf), bytes);
          assert.deepEqual(JSON.parse(await readFile(metadata, "utf8")), saved);
          await assert.rejects(readFile(journal), { code: "ENOENT" });
        } else {
          assert.equal(JSON.parse(await readFile(journal, "utf8")).status, "failed");
        }
      },
    );
  }
});

test("browser rejects private, special-use and encoded IP addresses", async () => {
  const blocked = [
    "127.0.0.1",
    "0.0.0.0",
    "10.0.0.1",
    "172.16.0.1",
    "172.31.255.255",
    "192.168.1.1",
    "169.254.169.254",
    "100.64.0.1",
    "100.127.255.254",
    "192.0.0.1",
    "192.0.2.1",
    "192.88.99.1",
    "198.18.0.1",
    "198.51.100.2",
    "203.0.113.1",
    "224.0.0.1",
    "255.255.255.255",
    "::",
    "::1",
    "::ffff:127.0.0.1",
    "::ffff:8.8.8.8",
    "fc00::1",
    "fd00::1",
    "fe80::1",
    "ff02::1",
    "2001:db8::1",
    "2001::1",
    "2002:7f00:1::1",
    "3fff::1",
  ];
  for (const address of blocked) assert.equal(isPublicIp(address), false, address);
  for (const address of ["8.8.8.8", "1.1.1.1", "2606:4700:4700::1111"]) {
    assert.equal(isPublicIp(address), true, address);
  }
  for (const url of [
    "http://2130706433",
    "http://0x7f000001",
    "http://0177.0.0.1",
    "http://127.1",
    "http://[::ffff:127.0.0.1]",
    "http://localhost.",
    "http://host.local",
    "file:///etc/passwd",
    "data:text/html,hello",
    "javascript:alert(1)",
    "https://user:[email protected]",
    "http://example.com:22",
  ])
    await assert.rejects(validatePublicUrl(url), { code: "BLOCKED_URL" }, url);
});

test("browser rejects DNS answers containing any private address and pins public resolution", async () => {
  await assert.rejects(
    validatePublicUrl("https://example.com", async () => [
      { address: "1.1.1.1", family: 4 },
      { address: "127.0.0.1", family: 4 },
    ]),
    { code: "BLOCKED_URL" },
  );
  const result = await validatePublicUrl("https://example.com/a", async () => [
    { address: "93.184.216.34", family: 4 },
  ]);
  assert.equal(result.address, "93.184.216.34");
  assert.equal(result.url.href, "https://example.com/a");
});

test("worker protects all controls, validates before launch, and health reveals no sessions", async () => {
  const dataDir = await mkdtemp(join(tmpdir(), "openmuse-worker-"));
  const savedId = "00000000-0000-4000-8000-000000000002";
  const downloadId = "00000000-0000-4000-8000-000000000003";
  const pendingId = "00000000-0000-4000-8000-000000000004";
  const downloadFolder = join(dataDir, savedId, "downloads");
  const outcomeFolder = join(dataDir, savedId, "download-outcomes");
  await mkdir(downloadFolder, { recursive: true });
  await mkdir(outcomeFolder, { recursive: true });
  await writeFile(join(downloadFolder, `${pendingId}.pdf`), "%PDF-1.7\npartial download");
  await writeFile(join(downloadFolder, `${pendingId}.json.tmp`), '{"id":');
  await writeFile(
    join(outcomeFolder, `${pendingId}.json`),
    JSON.stringify({
      id: pendingId,
      name: "unfinished.pdf",
      status: "pending",
      code: "DOWNLOAD_INTERRUPTED",
      message: "The download was interrupted.",
      createdAt: "2026-09-15T00:00:00.000Z",
    }),
  );
  await writeFile(
    join(dataDir, savedId, "session.json"),
    JSON.stringify({
      id: savedId,
      title: "Saved",
      url: "https://example.com",
      status: "active",
      updatedAt: new Date().toISOString(),
    }),
  );
  await writeFile(
    join(downloadFolder, `${downloadId}.json`),
    JSON.stringify({
      id: downloadId,
      name: "large.pdf",
      size: 10 * 1024 * 1024 + 1,
      mimeType: "application/pdf",
    }),
  );
  await writeFile(join(downloadFolder, `${downloadId}.pdf`), "");
  await truncate(join(downloadFolder, `${downloadId}.pdf`), 10 * 1024 * 1024 + 1);
  const worker = await createWorkerServer({
    token: "test-worker-token-at-least-32-characters",
    dataDir,
  });
  worker.server.listen(0, "127.0.0.1");
  await once(worker.server, "listening");
  const address = worker.server.address();
  assert(address && typeof address !== "string");
  const base = `http://127.0.0.1:${address.port}`;
  try {
    const health = await fetch(`${base}/health`);
    assert.deepEqual(await health.json(), { status: "ok" });
    for (const path of [
      "/sessions",
      "/sessions/invalid/screenshot",
      `/sessions/${savedId}/read`,
      "/anything",
    ]) {
      assert.equal((await fetch(`${base}${path}`)).status, 401);
    }
    const headers = {
      authorization: "Bearer test-worker-token-at-least-32-characters",
      "content-type": "application/json",
    };
    assert.equal((await fetch(`${base}/sessions`, { headers })).status, 200);
    const restored = await (await fetch(`${base}/sessions`, { headers })).json();
    assert.equal(
      restored[0].status,
      "closed",
      "restart must not report a closed browser as active",
    );
    const closedRead = await fetch(`${base}/sessions/${savedId}/read`, { headers });
    assert.equal(closedRead.status, 409);
    assert.equal((await closedRead.json()).error.code, "SESSION_CLOSED");
    const outcomes = await (
      await fetch(`${base}/sessions/${savedId}/downloads`, { headers })
    ).json();
    assert.equal(outcomes.downloads.length, 1);
    assert.equal(outcomes.failures[0]?.code, "DOWNLOAD_INTERRUPTED");
    await assert.rejects(readFile(join(downloadFolder, `${pendingId}.pdf`)), { code: "ENOENT" });
    await assert.rejects(readFile(join(downloadFolder, `${pendingId}.json.tmp`)), {
      code: "ENOENT",
    });
    const oversized = await fetch(`${base}/sessions/${savedId}/downloads/${downloadId}`, {
      headers,
    });
    assert.equal(oversized.status, 413);
    assert.equal((await oversized.json()).error.code, "DOWNLOAD_TOO_LARGE");
    const invalidDownload = await fetch(`${base}/sessions/${savedId}/downloads/not-a-uuid`, {
      headers,
    });
    assert.equal(invalidDownload.status, 400);
    const blocked = await fetch(`${base}/sessions`, {
      method: "POST",
      headers,
      body: JSON.stringify({ id: "00000000-0000-4000-8000-000000000001", url: "http://127.0.0.1" }),
    });
    assert.equal(blocked.status, 400);
    assert.equal((await blocked.json()).error.code, "BLOCKED_URL");
    const invalid = await fetch(`${base}/sessions`, {
      method: "POST",
      headers,
      body: JSON.stringify({ id: "../../escape", url: "https://example.com" }),
    });
    assert.equal(invalid.status, 400);
  } finally {
    await worker.close();
    await rm(dataDir, { recursive: true, force: true });
  }
});

test("egress proxy blocks HTTP and CONNECT traffic to local network destinations", async () => {
  const proxy = await startEgressProxy();
  const address = new URL(proxy.url);
  try {
    for (const method of ["GET", "CONNECT"]) {
      const status = await new Promise<number>((resolve, reject) => {
        const outgoing = request({
          hostname: address.hostname,
          port: address.port,
          method,
          path: method === "CONNECT" ? "127.0.0.1:443" : "http://127.0.0.1/health",
        });
        outgoing.on("response", (response) => {
          response.resume();
          resolve(response.statusCode ?? 0);
        });
        outgoing.on("connect", (response, socket) => {
          socket.destroy();
          resolve(response.statusCode ?? 0);
        });
        outgoing.on("error", reject);
        outgoing.end();
      });
      assert.equal(status, 403, method);
    }
  } finally {
    await proxy.close();
  }
});

test("the browser counts as connected only while its worker answers", async (t) => {
  let up = true;
  let clock = 0;
  const { db, config } = await browserFixture(t, (path) =>
    up && path === "/health" ? { data: { status: "ok" } } : { status: 503, data: {} },
  );
  const auth = new Auth(db, config, "test-signing-key");
  const service = new BrowserService(db, config, auth, new Files(db, config, auth), () => clock);
  assert.equal(await service.reachable(), true);
  up = false;
  assert.equal(await service.reachable(), true, "a recent answer is reused briefly");
  clock += 15_000;
  assert.equal(await service.reachable(), false);
  const unconfigured = new BrowserService(
    db,
    { ...config, workerUrl: undefined },
    auth,
    new Files(db, config, auth),
  );
  assert.equal(await unconfigured.reachable(), false);
});

test("the workspace reports the browser offline while its worker's health check fails", async (t) => {
  for (const up of [true, false]) {
    const { db, config } = await browserFixture(t, (path) =>
      up && path === "/health" ? { data: { status: "ok" } } : { status: 503, data: {} },
    );
    const { app, auth, agent } = await createApp(db, config);
    t.after(() => agent.stop());
    const { token } = await auth.session();
    const response = await app.request("/api/workspace", {
      headers: { Authorization: `Bearer ${token}` },
    });
    assert.equal(response.status, 200);
    const { connections } = (await response.json()) as {
      connections: { id: string; status: string }[];
    };
    assert.equal(
      connections.find((connection) => connection.id === "browser")?.status,
      up ? "connected" : "unavailable",
    );
  }
});