@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-K3WNSHUF.js

@@ -0,0 +1,1371 @@
+// src/browser/artifacts.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { atomicWrite, ulid } from "@wrongstack/core/utils";
+var ARTIFACT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var sweptRoots = /* @__PURE__ */ new Set();
+var MAX_SWEPT_ROOTS = 128;
+function sweepOldArtifacts(root) {
+  if (sweptRoots.has(root)) return;
+  while (sweptRoots.size >= MAX_SWEPT_ROOTS) {
+    const oldest = sweptRoots.values().next().value;
+    if (oldest === void 0) break;
+    sweptRoots.delete(oldest);
+  }
+  sweptRoots.add(root);
+  void (async () => {
+    const cutoff = Date.now() - ARTIFACT_RETENTION_MS;
+    let sessionDirs;
+    try {
+      const entries = await fs.readdir(root, { withFileTypes: true });
+      sessionDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return;
+    }
+    for (const sessionDir of sessionDirs) {
+      const dir = path.join(root, sessionDir);
+      let names;
+      try {
+        names = await fs.readdir(dir);
+      } catch {
+        continue;
+      }
+      let removed = 0;
+      for (const name of names) {
+        const target = path.join(dir, name);
+        try {
+          const stat3 = await fs.stat(target);
+          if (stat3.isFile() && stat3.mtimeMs < cutoff) {
+            await fs.rm(target, { force: true });
+            removed++;
+          }
+        } catch {
+        }
+      }
+      if (removed === names.length && names.length > 0) {
+        await fs.rmdir(dir).catch(() => void 0);
+      }
+    }
+  })();
+}
+var BrowserArtifactStore = class {
+  constructor(root) {
+    this.root = root;
+    sweepOldArtifacts(root);
+  }
+  root;
+  async write(sessionId, kind, extension, mimeType, content) {
+    const id = ulid();
+    const dir = path.join(this.root, safeSegment(sessionId));
+    const target = path.join(dir, `${id}.${extension.replace(/^\./, "")}`);
+    await atomicWrite(target, content, { mode: 384 });
+    return this.record(id, sessionId, kind, target, mimeType);
+  }
+  async record(id, sessionId, kind, target, mimeType) {
+    await fs.chmod(target, 384).catch(() => void 0);
+    const [stat3, sha256] = await Promise.all([fs.stat(target), hashFile(target)]);
+    const artifact = {
+      id,
+      kind,
+      sensitivity: "sensitive",
+      path: target,
+      mimeType,
+      sizeBytes: stat3.size,
+      sha256,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const metadataPath = path.join(path.dirname(target), `${id}.metadata.json`);
+    try {
+      await atomicWrite(
+        metadataPath,
+        `${JSON.stringify({
+          id: artifact.id,
+          sessionId: safeSegment(sessionId),
+          kind: artifact.kind,
+          sensitivity: artifact.sensitivity,
+          mimeType: artifact.mimeType,
+          sizeBytes: artifact.sizeBytes,
+          sha256: artifact.sha256,
+          createdAt: artifact.createdAt
+        })}
+`,
+        { mode: 384 }
+      );
+    } catch (error) {
+      await fs.rm(target, { force: true }).catch(() => void 0);
+      throw error;
+    }
+    return artifact;
+  }
+  pathFor(sessionId, extension) {
+    const id = ulid();
+    return {
+      id,
+      path: path.join(this.root, safeSegment(sessionId), `${id}.${extension.replace(/^\./, "")}`)
+    };
+  }
+  async describe(id, kind, target, mimeType) {
+    return this.record(id, path.basename(path.dirname(target)), kind, target, mimeType);
+  }
+};
+async function hashFile(target) {
+  const hash = createHash("sha256");
+  await new Promise((resolve3, reject) => {
+    const stream = createReadStream(target);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.once("error", reject);
+    stream.once("end", resolve3);
+  });
+  return hash.digest("hex");
+}
+function safeSegment(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80);
+}
+
+// src/browser/security.ts
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+import { assertNotPrivateHost, isPrivateIPv4, isPrivateIPv6 } from "@wrongstack/core/utils";
+var SAFE_SUBRESOURCE_PROTOCOLS = /* @__PURE__ */ new Set(["about:", "blob:", "data:"]);
+async function assertBrowserUrlAllowed(rawUrl, opts) {
+  const url = parseBrowserUrl(rawUrl, opts.navigation ?? true);
+  if (!opts.navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
+  if (!opts.allowPrivateHosts && !isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins)) {
+    await assertNotPrivateHost(url.hostname);
+  }
+  return url;
+}
+async function resolvePinnedBrowserTarget(rawUrl, opts = {}) {
+  const url = parseBrowserUrl(rawUrl, true);
+  const allowPrivate = opts.allowPrivateHosts === true || isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins);
+  const hostname = unbracket(url.hostname);
+  const literalFamily = net.isIP(hostname);
+  if (literalFamily === 4 || literalFamily === 6) {
+    if (!allowPrivate && isPrivateAddress(hostname, literalFamily)) {
+      throw new Error(`browser: blocked private/loopback address "${hostname}"`);
+    }
+    return { url, address: hostname, family: literalFamily };
+  }
+  if ((hostname === "localhost" || hostname.endsWith(".localhost")) && !allowPrivate) {
+    throw new Error("browser: blocked localhost target");
+  }
+  const lookup2 = opts.lookup ?? ((host) => dns.lookup(host, { all: true }));
+  let records;
+  try {
+    records = await lookup2(hostname);
+  } catch (error) {
+    throw new Error(
+      `browser: DNS resolution failed for "${hostname}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (records.length === 0) throw new Error(`browser: DNS returned no addresses for "${hostname}"`);
+  for (const record of records) {
+    if (record.family !== 4 && record.family !== 6) {
+      throw new Error(`browser: DNS returned an unsupported address family for "${hostname}"`);
+    }
+    if (!allowPrivate && isPrivateAddress(record.address, record.family)) {
+      throw new Error(`browser: resolved to private address ${record.address}`);
+    }
+  }
+  const selected = records[0];
+  return { url, address: selected.address, family: selected.family };
+}
+function parsePrivateOriginAllowlist(raw) {
+  if (!raw?.trim()) return [];
+  const origins = /* @__PURE__ */ new Set();
+  for (const entry of raw.split(",")) {
+    const candidate = entry.trim().replace(/^["']+|["']+$/gu, "");
+    if (!candidate) continue;
+    const url = parseBrowserUrl(candidate, true);
+    if (url.pathname !== "/" || url.search || url.hash) {
+      throw new Error(`browser: private origin allowlist entry must be an origin: "${candidate}"`);
+    }
+    origins.add(url.origin);
+  }
+  return [...origins];
+}
+function parseBrowserUrl(rawUrl, navigation) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error("browser: url must be an absolute URL");
+  }
+  if (!navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`browser: unsupported protocol "${url.protocol}"`);
+  }
+  if (url.username || url.password) {
+    throw new Error("browser: credentials in URLs are not allowed");
+  }
+  return url;
+}
+function isAllowedPrivateOrigin(url, origins) {
+  return origins?.includes(url.origin) ?? false;
+}
+function isPrivateAddress(address, family) {
+  return family === 4 ? isPrivateIPv4(address) : isPrivateIPv6(address);
+}
+function unbracket(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function safeBrowserUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return "about:blank";
+  }
+}
+function redactBrowserText(text) {
+  return text.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
+    /\b(api[-_ ]?key|access[-_ ]?token|auth[-_ ]?token|token|password|secret)\b\s*[:=]\s*[^\s,;]+/gi,
+    "$1=[REDACTED]"
+  );
+}
+
+// src/browser/network-guard-proxy.ts
+import * as http from "node:http";
+import * as net2 from "node:net";
+var BrowserNetworkGuardProxy = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.server = http.createServer((request2, response) => {
+      void this.forwardHttp(request2, response);
+    });
+    this.server.on("connect", (request2, socket, head) => {
+      void this.forwardConnect(request2, socket, head);
+    });
+    this.server.on("upgrade", (request2, socket, head) => {
+      void this.forwardUpgrade(request2, socket, head);
+    });
+    this.server.on("connection", (socket) => {
+      this.sockets.add(socket);
+      socket.once("close", () => this.sockets.delete(socket));
+      socket.on("error", () => {
+        socket.destroy();
+      });
+    });
+    this.server.on("clientError", (_error, socket) => {
+      socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+    });
+  }
+  options;
+  server;
+  sockets = /* @__PURE__ */ new Set();
+  startPromise;
+  url;
+  async start() {
+    if (this.url) return this.url;
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = new Promise((resolve3, reject) => {
+      const onError = (error) => {
+        this.server.off("listening", onListening);
+        reject(error);
+      };
+      const onListening = () => {
+        this.server.off("error", onError);
+        const address = this.server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("browser: network guard proxy failed to bind"));
+          return;
+        }
+        this.url = `http://127.0.0.1:${address.port}`;
+        resolve3(this.url);
+      };
+      this.server.once("error", onError);
+      this.server.once("listening", onListening);
+      this.server.listen(0, "127.0.0.1");
+    }).finally(() => {
+      this.startPromise = void 0;
+    });
+    return this.startPromise;
+  }
+  async close() {
+    this.url = void 0;
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    if (!this.server.listening) return;
+    await new Promise((resolve3) => this.server.close(() => resolve3()));
+  }
+  async forwardHttp(request2, response) {
+    try {
+      const target = await this.resolve(request2.url ?? "");
+      if (target.url.protocol !== "http:") throw new Error("browser: HTTPS must use CONNECT");
+      const headers = sanitizeHeaders(request2.headers);
+      headers.host = target.url.host;
+      const upstream = http.request({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 80),
+        method: request2.method,
+        path: `${target.url.pathname}${target.url.search}`,
+        headers,
+        agent: false
+      });
+      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => {
+        upstream.destroy(new Error("browser: upstream connection timed out"));
+      });
+      upstream.on("response", (upstreamResponse) => {
+        response.writeHead(
+          upstreamResponse.statusCode ?? 502,
+          sanitizeHeaders(upstreamResponse.headers)
+        );
+        upstreamResponse.pipe(response);
+      });
+      upstream.on("error", () => writeProxyError(response, 502, "Bad Gateway"));
+      request2.on("aborted", () => upstream.destroy());
+      request2.pipe(upstream);
+    } catch (error) {
+      writeProxyError(response, 403, policyBlockMessage(error));
+    }
+  }
+  async forwardConnect(request2, client, head) {
+    try {
+      const authority = request2.url ?? "";
+      const target = await this.resolve(`https://${authority}`);
+      const upstream = net2.connect({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 443)
+      });
+      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => upstream.destroy());
+      const onConnectError = () => {
+        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+      };
+      upstream.once("error", onConnectError);
+      upstream.once("connect", () => {
+        upstream.off("error", onConnectError);
+        client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        if (head.length > 0) upstream.write(head);
+        pipeDuplexPair(upstream, client);
+      });
+      client.once("close", () => upstream.destroy());
+    } catch (error) {
+      client.end(rawForbiddenResponse(policyBlockMessage(error)));
+    }
+  }
+  async forwardUpgrade(request2, client, head) {
+    let upstream;
+    try {
+      const rawUrl = request2.url ?? "";
+      const websocketUrl = new URL(rawUrl);
+      if (websocketUrl.protocol !== "ws:") {
+        throw new Error("browser: only plain ws upgrades are handled by the HTTP proxy");
+      }
+      websocketUrl.protocol = "http:";
+      const target = await this.resolve(websocketUrl.toString());
+      const headers = sanitizeHeaders(request2.headers, true);
+      headers.host = target.url.host;
+      upstream = http.request({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 80),
+        method: request2.method,
+        path: `${target.url.pathname}${target.url.search}`,
+        headers,
+        agent: false
+      });
+      upstream.once("upgrade", (response, upstreamSocket, upstreamHead) => {
+        writeRawResponseHead(client, response);
+        if (head.length > 0) upstreamSocket.write(head);
+        if (upstreamHead.length > 0) client.write(upstreamHead);
+        pipeDuplexPair(upstreamSocket, client);
+        client.once("close", () => upstreamSocket.destroy());
+      });
+      upstream.once("response", (response) => {
+        writeRawResponseHead(client, response);
+        response.once("error", () => client.destroy());
+        response.pipe(client);
+      });
+      upstream.once("error", () => {
+        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+      });
+      client.once("close", () => upstream?.destroy());
+      upstream.end();
+    } catch (error) {
+      upstream?.destroy();
+      client.end(rawForbiddenResponse(policyBlockMessage(error)));
+    }
+  }
+  resolve(rawUrl) {
+    return resolvePinnedBrowserTarget(rawUrl, {
+      allowPrivateHosts: this.options.allowPrivateHosts,
+      allowedPrivateOrigins: this.options.allowedPrivateOrigins,
+      lookup: this.options.lookup
+    });
+  }
+};
+function pipeDuplexPair(left, right) {
+  left.on("error", () => right.destroy());
+  right.on("error", () => left.destroy());
+  left.pipe(right);
+  right.pipe(left);
+}
+function sanitizeHeaders(headers, preserveUpgrade = false) {
+  const sanitized = { ...headers };
+  delete sanitized["proxy-authorization"];
+  delete sanitized["proxy-connection"];
+  if (!preserveUpgrade) delete sanitized.connection;
+  return sanitized;
+}
+function writeRawResponseHead(client, response) {
+  const status = response.statusCode ?? 502;
+  const statusText = response.statusMessage ?? "Bad Gateway";
+  const lines = [`HTTP/1.1 ${status} ${statusText}`];
+  for (let index = 0; index < response.rawHeaders.length; index += 2) {
+    lines.push(`${response.rawHeaders[index]}: ${response.rawHeaders[index + 1]}`);
+  }
+  client.write(`${lines.join("\r\n")}\r
+\r
+`);
+}
+function writeProxyError(response, status, message) {
+  if (response.headersSent || response.destroyed) return;
+  response.writeHead(status, { "content-type": "text/plain", connection: "close" });
+  response.end(message);
+}
+function policyBlockMessage(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  return reason ? `Blocked by browser network policy: ${reason}` : "Blocked by browser network policy";
+}
+function rawForbiddenResponse(message) {
+  return `HTTP/1.1 403 Forbidden\r
+Content-Type: text/plain\r
+Content-Length: ${Buffer.byteLength(message)}\r
+Connection: close\r
+\r
+` + message;
+}
+
+// src/browser/manager.ts
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+import { ulid as ulid2 } from "@wrongstack/core/utils";
+var DEFAULT_OPERATION_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_SNAPSHOT_CHARS = 64 * 1024;
+var DEFAULT_MAX_ENTRIES = 100;
+var BrowserSessionManager = class {
+  constructor(options, launcher = defaultLauncher) {
+    this.launcher = launcher;
+    this.artifacts = new BrowserArtifactStore(options.artifactRoot);
+    this.allowPrivateHosts = options.allowPrivateHosts ?? false;
+    this.allowedPrivateOrigins = options.allowedPrivateOrigins ?? [];
+    this.networkProxy = new BrowserNetworkGuardProxy({
+      allowPrivateHosts: this.allowPrivateHosts,
+      allowedPrivateOrigins: this.allowedPrivateOrigins
+    });
+    this.headless = options.headless ?? true;
+    this.operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+    this.maxSnapshotChars = options.maxSnapshotChars ?? DEFAULT_MAX_SNAPSHOT_CHARS;
+    this.maxConsoleEntries = options.maxConsoleEntries ?? DEFAULT_MAX_ENTRIES;
+    this.maxNetworkEntries = options.maxNetworkEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  launcher;
+  sessions = /* @__PURE__ */ new Map();
+  artifacts;
+  allowPrivateHosts;
+  allowedPrivateOrigins;
+  networkProxy;
+  headless;
+  operationTimeoutMs;
+  maxSnapshotChars;
+  maxConsoleEntries;
+  maxNetworkEntries;
+  browser;
+  launching;
+  async open(ownerId, input, signal) {
+    signal.throwIfAborted();
+    if (input.url) {
+      await assertBrowserUrlAllowed(input.url, {
+        allowPrivateHosts: this.allowPrivateHosts,
+        allowedPrivateOrigins: this.allowedPrivateOrigins,
+        navigation: true
+      });
+    }
+    const browser = await this.ensureBrowser(signal);
+    const proxyServer = await this.networkProxy.start();
+    const context = await abortable(
+      signal,
+      async () => {
+        const created = await browser.newContext({
+          acceptDownloads: false,
+          ignoreHTTPSErrors: false,
+          serviceWorkers: "block",
+          proxy: { server: proxyServer },
+          viewport: input.viewport ?? { width: 1440, height: 900 }
+        });
+        if (signal.aborted) {
+          await created.close().catch(() => void 0);
+          signal.throwIfAborted();
+        }
+        return created;
+      },
+      () => void 0
+    );
+    const session = {
+      id: ulid2(),
+      ownerId,
+      context,
+      page: await context.newPage(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tracing: input.trace ?? true,
+      console: [],
+      network: []
+    };
+    this.sessions.set(session.id, session);
+    this.attachEvidenceCollectors(session);
+    await context.route("**/*", async (route) => {
+      try {
+        await assertBrowserUrlAllowed(route.request().url(), {
+          allowPrivateHosts: this.allowPrivateHosts,
+          allowedPrivateOrigins: this.allowedPrivateOrigins,
+          navigation: false
+        });
+        await route.continue();
+      } catch {
+        this.pushNetwork(session, {
+          method: route.request().method(),
+          url: safeBrowserUrl(route.request().url()),
+          failed: true,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await route.abort("blockedbyclient");
+      }
+    });
+    try {
+      if (session.tracing) {
+        await context.tracing.start({ screenshots: true, snapshots: true, sources: false });
+      }
+      if (input.url) await this.navigate(session.id, ownerId, input.url, signal);
+      return await this.summary(session);
+    } catch (err) {
+      await context.close().catch(() => void 0);
+      this.sessions.delete(session.id);
+      await this.closeBrowserIfIdle();
+      throw err;
+    }
+  }
+  async list(ownerId) {
+    const owned = [...this.sessions.values()].filter((session) => session.ownerId === ownerId);
+    return Promise.all(owned.map((session) => this.summary(session)));
+  }
+  async navigate(id, ownerId, rawUrl, signal) {
+    await assertBrowserUrlAllowed(rawUrl, {
+      allowPrivateHosts: this.allowPrivateHosts,
+      allowedPrivateOrigins: this.allowedPrivateOrigins,
+      navigation: true
+    });
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.goto(rawUrl, {
+        waitUntil: "domcontentloaded",
+        timeout: this.operationTimeoutMs
+      })
+    );
+    return this.summary(session);
+  }
+  async snapshot(id, ownerId, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const raw = await this.runPageOperation(session, signal, async () => {
+      try {
+        return await session.page.locator("body").ariaSnapshot({ timeout: this.operationTimeoutMs });
+      } catch {
+        return await session.page.locator("body").innerText({ timeout: this.operationTimeoutMs });
+      }
+    });
+    const aria = redactBrowserText(raw);
+    const truncated = aria.length > this.maxSnapshotChars;
+    return {
+      session: await this.summary(session),
+      aria: truncated ? `${aria.slice(0, this.maxSnapshotChars)}
+\u2026[snapshot truncated]` : aria,
+      console: session.console.map((entry) => ({ ...entry })),
+      network: session.network.map((entry) => ({ ...entry })),
+      truncated
+    };
+  }
+  async screenshot(id, ownerId, input, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const bytes = await this.runPageOperation(
+      session,
+      signal,
+      () => input.selector ? session.page.locator(input.selector).screenshot({ type: "png", timeout: this.operationTimeoutMs }) : session.page.screenshot({ type: "png", fullPage: input.fullPage ?? false })
+    );
+    signal.throwIfAborted();
+    return this.artifacts.write(session.id, "screenshot", "png", "image/png", bytes);
+  }
+  async click(id, ownerId, selector, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).click({ timeout: this.operationTimeoutMs })
+    );
+  }
+  async type(id, ownerId, selector, text, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).fill(text, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async select(id, ownerId, selector, value, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).selectOption(value, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async press(id, ownerId, key, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(session, signal, () => session.page.keyboard.press(key));
+  }
+  async hover(id, ownerId, selector, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).hover({ timeout: this.operationTimeoutMs })
+    );
+  }
+  async wait(id, ownerId, input, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const timeout = Math.min(
+      Math.max(input.timeoutMs ?? this.operationTimeoutMs, 0),
+      this.operationTimeoutMs
+    );
+    await this.runPageOperation(
+      session,
+      signal,
+      () => input.selector ? session.page.locator(input.selector).waitFor({ state: "visible", timeout }) : session.page.waitForTimeout(timeout)
+    );
+  }
+  async drag(id, ownerId, from, to, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(from).dragTo(session.page.locator(to), {
+        timeout: this.operationTimeoutMs
+      })
+    );
+  }
+  async upload(id, ownerId, selector, files, projectRoot, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const root = path2.resolve(projectRoot);
+    const realRoot = await fs2.realpath(root);
+    const resolved = [];
+    for (const file of files) {
+      const absolute = path2.resolve(root, file);
+      const relative2 = path2.relative(root, absolute);
+      if (relative2.startsWith("..") || path2.isAbsolute(relative2)) {
+        throw new Error("browser: upload files must stay inside the project root");
+      }
+      let realFile;
+      try {
+        realFile = await fs2.realpath(absolute);
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          throw new Error(`browser: upload file not found: ${file}`);
+        }
+        throw error;
+      }
+      const realRelative = path2.relative(realRoot, realFile);
+      if (realRelative.startsWith("..") || path2.isAbsolute(realRelative)) {
+        throw new Error("browser: upload files must not escape the project root through a symlink");
+      }
+      const stat3 = await fs2.stat(realFile);
+      if (!stat3.isFile()) throw new Error(`browser: upload target is not a file: ${file}`);
+      resolved.push(realFile);
+    }
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).setInputFiles(resolved, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async evaluate(id, ownerId, expression, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const result = await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.evaluate(expression)
+    );
+    const serialized = JSON.stringify(result);
+    if (serialized && serialized.length > this.maxSnapshotChars) {
+      throw new Error(`browser: evaluation result exceeds ${this.maxSnapshotChars} characters`);
+    }
+    return result;
+  }
+  async close(id, ownerId) {
+    const session = this.requireOwned(id, ownerId);
+    let trace;
+    try {
+      if (session.tracing) {
+        const target = this.artifacts.pathFor(session.id, "zip");
+        await fs2.mkdir(path2.dirname(target.path), { recursive: true });
+        await session.context.tracing.stop({ path: target.path });
+        trace = await this.artifacts.describe(target.id, "trace", target.path, "application/zip");
+      }
+    } finally {
+      await session.context.close().catch(() => void 0);
+      this.sessions.delete(id);
+      await this.closeBrowserIfIdle();
+    }
+    return trace ? { trace } : {};
+  }
+  async closeOwner(ownerId) {
+    const ids = [...this.sessions.values()].filter((session) => session.ownerId === ownerId).map((session) => session.id);
+    for (const id of ids) await this.close(id, ownerId).catch(() => void 0);
+  }
+  /** True when the manager owns no live browser contexts. */
+  isIdle() {
+    return this.sessions.size === 0;
+  }
+  async dispose() {
+    for (const session of [...this.sessions.values()]) {
+      await session.context.close().catch(() => void 0);
+    }
+    this.sessions.clear();
+    const browser = this.browser;
+    this.browser = void 0;
+    this.launching = void 0;
+    await browser?.close().catch(() => void 0);
+    await this.networkProxy.close();
+  }
+  async ensureBrowser(signal) {
+    if (this.browser?.isConnected()) return this.browser;
+    if (!this.launching) {
+      this.launching = this.launcher(this.headless).then((browser) => {
+        this.browser = browser;
+        browser.on("disconnected", () => {
+          if (this.browser === browser) this.browser = void 0;
+          for (const [id, session] of this.sessions) {
+            if (session.context.browser() === browser) this.sessions.delete(id);
+          }
+        });
+        return browser;
+      });
+    }
+    try {
+      return await abortable(
+        signal,
+        () => this.launching,
+        async () => {
+          const browser = await this.launching?.catch(() => void 0);
+          await browser?.close().catch(() => void 0);
+        }
+      );
+    } finally {
+      this.launching = void 0;
+    }
+  }
+  requireOwned(id, ownerId) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`browser: unknown session "${id}"`);
+    if (session.ownerId !== ownerId) throw new Error("browser: session belongs to another agent");
+    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return session;
+  }
+  async summary(session) {
+    return {
+      id: session.id,
+      ownerId: session.ownerId,
+      url: safeBrowserUrl(session.page.url()),
+      title: redactBrowserText(await session.page.title().catch(() => "")),
+      createdAt: session.createdAt,
+      lastUsedAt: session.lastUsedAt,
+      tracing: session.tracing
+    };
+  }
+  attachEvidenceCollectors(session) {
+    session.page.on("console", (message) => {
+      pushBounded(
+        session.console,
+        {
+          level: message.type(),
+          text: redactBrowserText(message.text()).slice(0, 4096),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        this.maxConsoleEntries
+      );
+    });
+    session.page.on("response", (response) => {
+      this.pushNetwork(session, {
+        method: response.request().method(),
+        url: safeBrowserUrl(response.url()),
+        status: response.status(),
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    session.page.on("requestfailed", (request2) => {
+      this.pushNetwork(session, {
+        method: request2.method(),
+        url: safeBrowserUrl(request2.url()),
+        failed: true,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  pushNetwork(session, entry) {
+    pushBounded(session.network, entry, this.maxNetworkEntries);
+  }
+  async runPageOperation(session, signal, operation) {
+    signal.throwIfAborted();
+    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return abortable(signal, operation, async () => {
+      await session.context.close().catch(() => void 0);
+      this.sessions.delete(session.id);
+      await this.closeBrowserIfIdle();
+    });
+  }
+  async closeBrowserIfIdle() {
+    if (this.sessions.size > 0 || !this.browser) return;
+    const browser = this.browser;
+    this.browser = void 0;
+    await browser.close().catch(() => void 0);
+  }
+};
+async function defaultLauncher(headless) {
+  try {
+    const { chromium } = await import("@playwright/test");
+    return await chromium.launch({ headless });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `browser: Playwright Chromium is unavailable (${detail}). Run "pnpm exec playwright install chromium".`
+    );
+  }
+}
+async function browserInstallationDiagnostics() {
+  try {
+    const { chromium } = await import("@playwright/test");
+    const executablePath = chromium.executablePath();
+    await fs2.access(executablePath);
+    return { available: true, executablePath, message: "Playwright Chromium is available." };
+  } catch {
+    return {
+      available: false,
+      message: 'Playwright Chromium is unavailable. Run "pnpm exec playwright install chromium".'
+    };
+  }
+}
+function pushBounded(target, value, limit) {
+  target.push(value);
+  if (target.length > limit) target.splice(0, target.length - limit);
+}
+async function abortable(signal, operation, onAbort) {
+  signal.throwIfAborted();
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    let aborting = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", abort);
+      fn();
+    };
+    const abort = () => {
+      aborting = true;
+      void Promise.resolve(onAbort()).finally(() => {
+        finish(() => reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted")));
+      });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    operation().then(
+      (value) => {
+        if (!aborting) finish(() => resolve3(value));
+      },
+      (err) => {
+        if (!aborting) finish(() => reject(err));
+      }
+    );
+  });
+}
+
+// src/browser/tools.ts
+import * as path3 from "node:path";
+import { ToolCapabilities } from "@wrongstack/core/security";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+var managers = /* @__PURE__ */ new Map();
+var cleanupSignalByContext = /* @__PURE__ */ new WeakMap();
+function managerFor(ctx) {
+  const root = path3.resolve(ctx.projectRoot);
+  let manager = managers.get(root);
+  if (!manager) {
+    const wpaths = resolveWstackPaths({ projectRoot: root });
+    manager = new BrowserSessionManager({
+      artifactRoot: path3.join(wpaths.projectDir, "browser-artifacts"),
+      allowedPrivateOrigins: parsePrivateOriginAllowlist(
+        process.env["WRONGSTACK_BROWSER_PRIVATE_ORIGINS"]
+      )
+    });
+    managers.set(root, manager);
+  }
+  const runSignal = ctx.signal;
+  if (cleanupSignalByContext.get(ctx) !== runSignal) {
+    cleanupSignalByContext.set(ctx, runSignal);
+    const managerForRun = manager;
+    const rootForRun = root;
+    const ownerForRun = owner(ctx);
+    ctx.registerAbortHook?.(async () => {
+      if (cleanupSignalByContext.get(ctx) === runSignal) {
+        cleanupSignalByContext.delete(ctx);
+      }
+      await managerForRun.closeOwner(ownerForRun);
+      if (managerForRun.isIdle() && managers.get(rootForRun) === managerForRun) {
+        managers.delete(rootForRun);
+        await managerForRun.dispose();
+      }
+    });
+  }
+  return manager;
+}
+function owner(ctx) {
+  return ctx.agentId || "leader";
+}
+function json(value) {
+  return JSON.stringify(value, null, 2);
+}
+var sessionIdSchema = {
+  type: "string",
+  minLength: 1,
+  description: "Browser session id returned by browser_open."
+};
+var browserOpenTool = {
+  name: "browser_open",
+  description: "Open an isolated first-party Playwright browser session, optionally navigating to a URL. Private/localhost origins are blocked by default; enable specific origins via the WRONGSTACK_BROWSER_PRIVATE_ORIGINS env allowlist.",
+  usageHint: "browser_open({ url?, width?, height?, trace? })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  subjectKey: "url",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "Optional absolute http(s) URL." },
+      width: { type: "integer", minimum: 320, maximum: 3840 },
+      height: { type: "integer", minimum: 240, maximum: 2160 },
+      trace: { type: "boolean", description: "Capture a Playwright trace; defaults to true." }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const viewport = input.width || input.height ? { width: input.width ?? 1440, height: input.height ?? 900 } : void 0;
+    return json(
+      await managerFor(ctx).open(
+        owner(ctx),
+        { url: input.url, viewport, trace: input.trace },
+        opts.signal
+      )
+    );
+  }
+};
+var browserListTool = {
+  name: "browser_list",
+  description: "List browser sessions owned by the current agent without exposing other agents sessions.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: { type: "object", properties: {} },
+  async execute(_input, ctx) {
+    return json(await managerFor(ctx).list(owner(ctx)));
+  }
+};
+var browserStatusTool = {
+  name: "browser_status",
+  description: "Check whether first-party Playwright Chromium is installed and ready to launch.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.TOOL_META],
+  inputSchema: { type: "object", properties: {} },
+  async execute() {
+    return json(await browserInstallationDiagnostics());
+  }
+};
+var browserNavigateTool = {
+  name: "browser_navigate",
+  description: "Navigate an owned browser session to an approved http(s) URL. Private/localhost origins are blocked by default; enable specific origins via the WRONGSTACK_BROWSER_PRIVATE_ORIGINS env allowlist.",
+  usageHint: "browser_navigate({ sessionId, url })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  subjectKey: "url",
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema, url: { type: "string", minLength: 1 } },
+    required: ["sessionId", "url"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).navigate(input.sessionId, owner(ctx), input.url, opts.signal)
+    );
+  }
+};
+var browserSnapshotTool = {
+  name: "browser_snapshot",
+  description: "Return bounded accessibility state plus redacted console and network summaries.",
+  usageHint: "browser_snapshot({ sessionId })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    return json(await managerFor(ctx).snapshot(input.sessionId, owner(ctx), opts.signal));
+  }
+};
+var browserScreenshotTool = {
+  name: "browser_screenshot",
+  description: "Capture a page or element PNG and return sensitive artifact metadata with integrity hash.",
+  usageHint: "browser_screenshot({ sessionId, fullPage?, selector? })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "selector",
+  mutating: true,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      fullPage: { type: "boolean" },
+      selector: { type: "string", minLength: 1 }
+    },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).screenshot(
+        input.sessionId,
+        owner(ctx),
+        { fullPage: input.fullPage, selector: input.selector },
+        opts.signal
+      )
+    );
+  }
+};
+function selectorTool(name, description, run) {
+  return {
+    name,
+    description,
+    usageHint: `${name}({ sessionId, selector })`,
+    permission: "confirm",
+    // WS-046: the element/expression acted on, not the sessionId — a trust
+    // rule must distinguish clicking one control from another.
+    subjectKey: "selector",
+    mutating: true,
+    riskTier: "standard",
+    capabilities: [ToolCapabilities.NET_OUTBOUND],
+    inputSchema: {
+      type: "object",
+      properties: { sessionId: sessionIdSchema, selector: { type: "string", minLength: 1 } },
+      required: ["sessionId", "selector"]
+    },
+    async execute(input, ctx, opts) {
+      await run(managerFor(ctx), input, owner(ctx), opts.signal);
+      return "ok";
+    }
+  };
+}
+var browserClickTool = selectorTool(
+  "browser_click",
+  "Click an element in an owned browser session.",
+  (manager, input, ownerId, signal) => manager.click(input.sessionId, ownerId, input.selector, signal)
+);
+var browserHoverTool = selectorTool(
+  "browser_hover",
+  "Hover an element in an owned browser session.",
+  (manager, input, ownerId, signal) => manager.hover(input.sessionId, ownerId, input.selector, signal)
+);
+var browserTypeTool = {
+  name: "browser_type",
+  description: "Fill an input in an owned browser session. Use secretEnv instead of text for credentials so values stay out of tool arguments and session audit.",
+  usageHint: "browser_type({ sessionId, selector, text? | secretEnv? })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "selector",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      text: { type: "string" },
+      secretEnv: {
+        type: "string",
+        pattern: "^[A-Z_][A-Z0-9_]*$",
+        description: "Host environment variable resolved only at execution time."
+      }
+    },
+    required: ["sessionId", "selector"]
+  },
+  validate(input) {
+    return input.text === void 0 === (input.secretEnv === void 0) ? ["exactly one of text or secretEnv is required"] : [];
+  },
+  async execute(input, ctx, opts) {
+    const value = input.text ?? (input.secretEnv ? process.env[input.secretEnv] : void 0);
+    if (value === void 0) {
+      throw new Error(`browser: secret environment variable "${input.secretEnv ?? ""}" is not set`);
+    }
+    await managerFor(ctx).type(input.sessionId, owner(ctx), input.selector, value, opts.signal);
+    return "ok";
+  }
+};
+var browserSelectTool = {
+  name: "browser_select",
+  description: "Select an option in an owned browser session.",
+  usageHint: "browser_select({ sessionId, selector, value })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "selector",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      value: { type: "string" }
+    },
+    required: ["sessionId", "selector", "value"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).select(
+      input.sessionId,
+      owner(ctx),
+      input.selector,
+      input.value,
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserPressTool = {
+  name: "browser_press",
+  description: "Press a keyboard key in an owned browser session.",
+  usageHint: "browser_press({ sessionId, key })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "key",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema, key: { type: "string", minLength: 1 } },
+    required: ["sessionId", "key"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).press(input.sessionId, owner(ctx), input.key, opts.signal);
+    return "ok";
+  }
+};
+var browserDragTool = {
+  name: "browser_drag",
+  description: "Drag one element to another in an owned browser session.",
+  usageHint: "browser_drag({ sessionId, from, to })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "from",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      from: { type: "string", minLength: 1 },
+      to: { type: "string", minLength: 1 }
+    },
+    required: ["sessionId", "from", "to"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).drag(input.sessionId, owner(ctx), input.from, input.to, opts.signal);
+    return "ok";
+  }
+};
+var browserWaitTool = {
+  name: "browser_wait",
+  description: "Wait for an element or a bounded duration in an owned browser session.",
+  usageHint: "browser_wait({ sessionId, selector?, timeoutMs? })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      timeoutMs: { type: "integer", minimum: 0, maximum: 3e4 }
+    },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).wait(
+      input.sessionId,
+      owner(ctx),
+      { selector: input.selector, timeoutMs: input.timeoutMs },
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserEvaluateTool = {
+  name: "browser_evaluate",
+  description: "Evaluate bounded JavaScript in the page. Requires confirmation because page code is arbitrary.",
+  usageHint: "browser_evaluate({ sessionId, expression })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "expression",
+  mutating: true,
+  riskTier: "destructive",
+  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.TOOL_MUTATE_ANY],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      expression: { type: "string", minLength: 1, maxLength: 16384 }
+    },
+    required: ["sessionId", "expression"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).evaluate(input.sessionId, owner(ctx), input.expression, opts.signal)
+    );
+  }
+};
+var browserUploadTool = {
+  name: "browser_upload",
+  description: "Upload project-local files through a file input in an owned browser session.",
+  usageHint: "browser_upload({ sessionId, selector, files })",
+  permission: "confirm",
+  // WS-046: the element/expression acted on, not the sessionId — a trust
+  // rule must distinguish clicking one control from another.
+  subjectKey: "selector",
+  mutating: true,
+  riskTier: "destructive",
+  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.FS_READ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      files: { type: "array", minItems: 1, maxItems: 20, items: { type: "string", minLength: 1 } }
+    },
+    required: ["sessionId", "selector", "files"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).upload(
+      input.sessionId,
+      owner(ctx),
+      input.selector,
+      input.files,
+      ctx.projectRoot,
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserCloseTool = {
+  name: "browser_close",
+  description: "Close an owned browser session, reclaim its context, and return sensitive trace metadata.",
+  usageHint: "browser_close({ sessionId })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx) {
+    return json(await managerFor(ctx).close(input.sessionId, owner(ctx)));
+  }
+};
+var browserTools = [
+  browserOpenTool,
+  browserStatusTool,
+  browserListTool,
+  browserNavigateTool,
+  browserSnapshotTool,
+  browserScreenshotTool,
+  browserClickTool,
+  browserTypeTool,
+  browserSelectTool,
+  browserPressTool,
+  browserHoverTool,
+  browserDragTool,
+  browserWaitTool,
+  browserEvaluateTool,
+  browserUploadTool,
+  browserCloseTool
+];
+for (const tool of browserTools) tool.icon = "web";
+for (const tool of browserTools) tool.timeoutMs ??= 6e4;
+async function shutdownBrowserTools() {
+  const active = [...managers.values()];
+  managers.clear();
+  await Promise.all(active.map((manager) => manager.dispose()));
+}
+
+export {
+  BrowserArtifactStore,
+  assertBrowserUrlAllowed,
+  resolvePinnedBrowserTarget,
+  parsePrivateOriginAllowlist,
+  safeBrowserUrl,
+  redactBrowserText,
+  BrowserNetworkGuardProxy,
+  BrowserSessionManager,
+  browserInstallationDiagnostics,
+  browserOpenTool,
+  browserListTool,
+  browserStatusTool,
+  browserNavigateTool,
+  browserSnapshotTool,
+  browserScreenshotTool,
+  browserClickTool,
+  browserHoverTool,
+  browserTypeTool,
+  browserSelectTool,
+  browserPressTool,
+  browserDragTool,
+  browserWaitTool,
+  browserEvaluateTool,
+  browserUploadTool,
+  browserCloseTool,
+  browserTools,
+  shutdownBrowserTools
+};
+//# sourceMappingURL=chunk-K3WNSHUF.js.map