@ricsam/r5d-browser 0.0.47 → 0.0.49

package/README.md

@@ -8,3 +8,7 @@ r5d-browser start
 ```
 
 The profile is stored under `~/.r5d/browser/profile`. Completed downloads are retained under `~/.r5d/browser/downloads`; agents can list them and copy a selected file into the active session's artifacts. That artifact is then synchronized to every connected worker. Browser screenshots are session artifacts in r5d.dev and are not retained by the browser process.
+
+Agents can also create loopback-only TCP port forwards from this Mac to the worker bound to a chat. For example, a forward can map Chromium's `localhost:4323` to `127.0.0.1:3232` on that worker. The relay preserves raw TCP traffic, including HTTP, HTTPS, WebSockets, HMR, and SSE; it never exposes a public listener or permits an arbitrary target host.
+
+Port forwards remain active across agent turns and r5d.dev control-connection reconnects. They are owned by the running `r5d-browser` process, so restarting that process ends them. Agents can list and stop forwards, and the user can inspect or stop them from Settings.

package/dist/cjs/main.cjs

@@ -29,6 +29,7 @@ var import_node_child_process = require("node:child_process");
 var import_promises = require("node:timers/promises");
 var import_ws = __toESM(require("ws"), 1);
 var import_playwright_install = require("./playwright-install.cjs");
+var import_port_forward_manager = require("./port-forward-manager.cjs");
 const DEFAULT_BASE_URL = "https://r5d.dev";
 const PACKAGE_NAME = "@ricsam/r5d-browser";
 const RECONNECT_DELAY_MS = 2e3;
@@ -445,9 +446,11 @@ async function connectLoop(params) {
             arch: process.arch,
             version: findVersion(),
             chromiumVersion: params.chromiumVersion,
-            profilePath: params.profilePath
+            profilePath: params.profilePath,
+            capabilities: { portForwarding: true }
           },
-          tabs: await params.runtime.listTabs()
+          tabs: await params.runtime.listTabs(),
+          portForwards: params.portForwards.list()
         })
       );
       let lastServerMessageAt = Date.now();
@@ -463,6 +466,38 @@ async function connectLoop(params) {
               socket?.send(JSON.stringify({ type: "pong" }));
               return;
             }
+            if (message.type === "port_forward_start") {
+              try {
+                await params.portForwards.start(message.forward);
+                socket?.send(
+                  JSON.stringify({ type: "port_forward_result", requestId: message.requestId, forward: message.forward })
+                );
+              } catch (error) {
+                socket?.send(
+                  JSON.stringify({
+                    type: "port_forward_result",
+                    requestId: message.requestId,
+                    error: error instanceof Error ? error.message : String(error)
+                  })
+                );
+              }
+              return;
+            }
+            if (message.type === "port_forward_stop") {
+              try {
+                await params.portForwards.stop(message.forwardId);
+                socket?.send(JSON.stringify({ type: "port_forward_result", requestId: message.requestId }));
+              } catch (error) {
+                socket?.send(
+                  JSON.stringify({
+                    type: "port_forward_result",
+                    requestId: message.requestId,
+                    error: error instanceof Error ? error.message : String(error)
+                  })
+                );
+              }
+              return;
+            }
             if (message.type !== "operation") return;
             try {
               const beforeTabs = await params.runtime.listTabs();
@@ -521,19 +556,23 @@ async function start(options) {
   });
   if (context.pages().length === 0) await context.newPage();
   const runtime = new BrowserRuntime(context, downloadsPath);
+  const instanceId = loadInstanceId();
+  const portForwards = new import_port_forward_manager.BrowserPortForwardManager(baseUrl, token, instanceId);
   process.stdout.write(`[r5d-browser] profile: ${profilePath}
 `);
   process.stdout.write(`[r5d-browser] downloads: ${downloadsPath}
 `);
   process.stdout.write(`[r5d-browser] agents use synthetic Chromium input; your system pointer and keyboard stay untouched.
 `);
-  process.on("SIGINT", () => void context.close().finally(() => process.exit(0)));
-  process.on("SIGTERM", () => void context.close().finally(() => process.exit(0)));
+  const shutdown = () => void Promise.all([portForwards.close(), context.close()]).finally(() => process.exit(0));
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
   return connectLoop({
     runtime,
+    portForwards,
     baseUrl,
     token,
-    instanceId: loadInstanceId(),
+    instanceId,
     profilePath,
     chromiumVersion: context.browser()?.version() ?? "unknown"
   });

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-browser",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "type": "commonjs"
 }

package/dist/cjs/port-forward-manager.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var port_forward_manager_exports = {};
+__export(port_forward_manager_exports, {
+  BrowserPortForwardManager: () => BrowserPortForwardManager
+});
+module.exports = __toCommonJS(port_forward_manager_exports);
+var import_node_net = __toESM(require("node:net"), 1);
+var import_ws = __toESM(require("ws"), 1);
+const RELAY_FRAME_BYTES = 64 * 1024;
+const RELAY_PAUSE_BYTES = 1024 * 1024;
+const RELAY_RESUME_BYTES = 256 * 1024;
+function relayUrl(baseUrl, instanceId, forwardId, relayConnectionId) {
+  const url = new URL("/browser/port-forward/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("instance", instanceId);
+  url.searchParams.set("forward", forwardId);
+  url.searchParams.set("connection", relayConnectionId);
+  return url.toString();
+}
+async function listen(server, port, host, ipv6Only = false) {
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen({ port, host, ipv6Only, exclusive: true });
+  });
+}
+async function closeServer(server) {
+  if (!server.listening) return;
+  await new Promise((resolve) => server.close(() => resolve()));
+}
+function rawDataBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (Array.isArray(data)) return Buffer.concat(data);
+  return Buffer.from(data);
+}
+class BrowserPortForwardManager {
+  constructor(baseUrl, token, instanceId) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.instanceId = instanceId;
+  }
+  baseUrl;
+  token;
+  instanceId;
+  forwards = /* @__PURE__ */ new Map();
+  forwardByBrowserPort = /* @__PURE__ */ new Map();
+  operationQueue = Promise.resolve();
+  list() {
+    return [...this.forwards.values()].map(({ definition }) => ({ ...definition }));
+  }
+  start(definition) {
+    return this.enqueue(() => this.startNow(definition));
+  }
+  stop(forwardId) {
+    return this.enqueue(() => this.stopNow(forwardId));
+  }
+  close() {
+    return this.enqueue(async () => {
+      for (const forwardId of [...this.forwards.keys()]) await this.stopNow(forwardId);
+    });
+  }
+  enqueue(operation) {
+    const result = this.operationQueue.then(operation, operation);
+    this.operationQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async startNow(definition) {
+    const existing = this.forwards.get(definition.forwardId);
+    if (existing) {
+      if (JSON.stringify(existing.definition) === JSON.stringify(definition)) return;
+      throw new Error(`Port forward ${definition.forwardId} already exists with different settings.`);
+    }
+    const occupyingId = this.forwardByBrowserPort.get(definition.browserPort);
+    if (occupyingId) throw new Error(`Browser port ${definition.browserPort} is already used by forward ${occupyingId}.`);
+    const active = { definition: { ...definition }, servers: [], relays: /* @__PURE__ */ new Set() };
+    const accept = (socket) => this.acceptConnection(active, socket);
+    const ipv4 = import_node_net.default.createServer({ allowHalfOpen: true }, accept);
+    const ipv6 = import_node_net.default.createServer({ allowHalfOpen: true }, accept);
+    const servers = [ipv4, ipv6];
+    active.servers = servers;
+    try {
+      await listen(ipv4, definition.browserPort, "127.0.0.1");
+      await listen(ipv6, definition.browserPort, "::1", true);
+    } catch (error) {
+      await Promise.all(servers.map(closeServer));
+      throw new Error(
+        `Could not bind localhost:${definition.browserPort}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    this.forwards.set(definition.forwardId, active);
+    this.forwardByBrowserPort.set(definition.browserPort, definition.forwardId);
+  }
+  async stopNow(forwardId) {
+    const active = this.forwards.get(forwardId);
+    if (!active) return;
+    this.forwards.delete(forwardId);
+    this.forwardByBrowserPort.delete(active.definition.browserPort);
+    for (const connection of active.relays) {
+      connection.socket.destroy();
+      connection.relay.close(1e3, "Port forward stopped");
+    }
+    active.relays.clear();
+    await Promise.all(active.servers.map(closeServer));
+  }
+  acceptConnection(active, socket) {
+    socket.pause();
+    socket.setNoDelay(true);
+    const relayConnectionId = crypto.randomUUID();
+    const relay = new import_ws.default(relayUrl(this.baseUrl, this.instanceId, active.definition.forwardId, relayConnectionId), {
+      headers: { Authorization: `Bearer ${this.token}` },
+      perMessageDeflate: false
+    });
+    const connection = { socket, relay };
+    active.relays.add(connection);
+    let ready = false;
+    const pendingChunks = [];
+    let pendingBytes = 0;
+    let resumeTimer;
+    let closing = false;
+    const cleanup = () => {
+      if (closing) return;
+      closing = true;
+      if (resumeTimer) clearInterval(resumeTimer);
+      active.relays.delete(connection);
+      socket.destroy();
+      if (relay.readyState === import_ws.default.OPEN || relay.readyState === import_ws.default.CONNECTING) relay.close();
+    };
+    const waitForRelayDrain = () => {
+      if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
+      socket.pause();
+      resumeTimer = setInterval(() => {
+        if (relay.readyState !== import_ws.default.OPEN) return cleanup();
+        if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
+        clearInterval(resumeTimer);
+        resumeTimer = void 0;
+        if (ready) socket.resume();
+      }, 10);
+    };
+    const sendChunk = (chunk) => {
+      for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
+        relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
+      }
+      waitForRelayDrain();
+    };
+    relay.on("message", (data, isBinary) => {
+      if (!isBinary) {
+        let control;
+        try {
+          control = JSON.parse(rawDataBuffer(data).toString("utf8"));
+        } catch {
+          return cleanup();
+        }
+        if (control.type === "ready") {
+          ready = true;
+          for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+          pendingBytes = 0;
+          socket.resume();
+        } else if (control.type === "end") {
+          socket.end();
+        } else if (control.type === "error") {
+          socket.destroy(new Error(control.error || "Port-forward relay failed."));
+        }
+        return;
+      }
+      if (!socket.write(rawDataBuffer(data))) {
+        relay.pause();
+        socket.once("drain", () => relay.resume());
+      }
+    });
+    relay.once("error", cleanup);
+    relay.once("close", cleanup);
+    socket.on("data", (chunk) => {
+      if (!ready || relay.readyState !== import_ws.default.OPEN) {
+        pendingBytes += chunk.byteLength;
+        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
+        pendingChunks.push(Buffer.from(chunk));
+        socket.pause();
+        return;
+      }
+      sendChunk(chunk);
+    });
+    socket.on("end", () => {
+      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "end" }));
+    });
+    socket.on("error", (error) => {
+      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "error", error: error.message }));
+    });
+    socket.on("close", cleanup);
+    socket.pause();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserPortForwardManager
+});

package/dist/mjs/main.mjs

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process";
 import { setTimeout as sleep } from "node:timers/promises";
 import WebSocket from "ws";
 import { resolvePlaywrightCliPath } from "./playwright-install.mjs";
+import { BrowserPortForwardManager } from "./port-forward-manager.mjs";
 const DEFAULT_BASE_URL = "https://r5d.dev";
 const PACKAGE_NAME = "@ricsam/r5d-browser";
 const RECONNECT_DELAY_MS = 2e3;
@@ -422,9 +423,11 @@ async function connectLoop(params) {
             arch: process.arch,
             version: findVersion(),
             chromiumVersion: params.chromiumVersion,
-            profilePath: params.profilePath
+            profilePath: params.profilePath,
+            capabilities: { portForwarding: true }
           },
-          tabs: await params.runtime.listTabs()
+          tabs: await params.runtime.listTabs(),
+          portForwards: params.portForwards.list()
         })
       );
       let lastServerMessageAt = Date.now();
@@ -440,6 +443,38 @@ async function connectLoop(params) {
               socket?.send(JSON.stringify({ type: "pong" }));
               return;
             }
+            if (message.type === "port_forward_start") {
+              try {
+                await params.portForwards.start(message.forward);
+                socket?.send(
+                  JSON.stringify({ type: "port_forward_result", requestId: message.requestId, forward: message.forward })
+                );
+              } catch (error) {
+                socket?.send(
+                  JSON.stringify({
+                    type: "port_forward_result",
+                    requestId: message.requestId,
+                    error: error instanceof Error ? error.message : String(error)
+                  })
+                );
+              }
+              return;
+            }
+            if (message.type === "port_forward_stop") {
+              try {
+                await params.portForwards.stop(message.forwardId);
+                socket?.send(JSON.stringify({ type: "port_forward_result", requestId: message.requestId }));
+              } catch (error) {
+                socket?.send(
+                  JSON.stringify({
+                    type: "port_forward_result",
+                    requestId: message.requestId,
+                    error: error instanceof Error ? error.message : String(error)
+                  })
+                );
+              }
+              return;
+            }
             if (message.type !== "operation") return;
             try {
               const beforeTabs = await params.runtime.listTabs();
@@ -498,19 +533,23 @@ async function start(options) {
   });
   if (context.pages().length === 0) await context.newPage();
   const runtime = new BrowserRuntime(context, downloadsPath);
+  const instanceId = loadInstanceId();
+  const portForwards = new BrowserPortForwardManager(baseUrl, token, instanceId);
   process.stdout.write(`[r5d-browser] profile: ${profilePath}
 `);
   process.stdout.write(`[r5d-browser] downloads: ${downloadsPath}
 `);
   process.stdout.write(`[r5d-browser] agents use synthetic Chromium input; your system pointer and keyboard stay untouched.
 `);
-  process.on("SIGINT", () => void context.close().finally(() => process.exit(0)));
-  process.on("SIGTERM", () => void context.close().finally(() => process.exit(0)));
+  const shutdown = () => void Promise.all([portForwards.close(), context.close()]).finally(() => process.exit(0));
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
   return connectLoop({
     runtime,
+    portForwards,
     baseUrl,
     token,
-    instanceId: loadInstanceId(),
+    instanceId,
     profilePath,
     chromiumVersion: context.browser()?.version() ?? "unknown"
   });

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-browser",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "type": "module"
 }

package/dist/mjs/port-forward-manager.mjs

@@ -0,0 +1,199 @@
+import net, {} from "node:net";
+import WebSocket, {} from "ws";
+const RELAY_FRAME_BYTES = 64 * 1024;
+const RELAY_PAUSE_BYTES = 1024 * 1024;
+const RELAY_RESUME_BYTES = 256 * 1024;
+function relayUrl(baseUrl, instanceId, forwardId, relayConnectionId) {
+  const url = new URL("/browser/port-forward/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("instance", instanceId);
+  url.searchParams.set("forward", forwardId);
+  url.searchParams.set("connection", relayConnectionId);
+  return url.toString();
+}
+async function listen(server, port, host, ipv6Only = false) {
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen({ port, host, ipv6Only, exclusive: true });
+  });
+}
+async function closeServer(server) {
+  if (!server.listening) return;
+  await new Promise((resolve) => server.close(() => resolve()));
+}
+function rawDataBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (Array.isArray(data)) return Buffer.concat(data);
+  return Buffer.from(data);
+}
+class BrowserPortForwardManager {
+  constructor(baseUrl, token, instanceId) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.instanceId = instanceId;
+  }
+  baseUrl;
+  token;
+  instanceId;
+  forwards = /* @__PURE__ */ new Map();
+  forwardByBrowserPort = /* @__PURE__ */ new Map();
+  operationQueue = Promise.resolve();
+  list() {
+    return [...this.forwards.values()].map(({ definition }) => ({ ...definition }));
+  }
+  start(definition) {
+    return this.enqueue(() => this.startNow(definition));
+  }
+  stop(forwardId) {
+    return this.enqueue(() => this.stopNow(forwardId));
+  }
+  close() {
+    return this.enqueue(async () => {
+      for (const forwardId of [...this.forwards.keys()]) await this.stopNow(forwardId);
+    });
+  }
+  enqueue(operation) {
+    const result = this.operationQueue.then(operation, operation);
+    this.operationQueue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async startNow(definition) {
+    const existing = this.forwards.get(definition.forwardId);
+    if (existing) {
+      if (JSON.stringify(existing.definition) === JSON.stringify(definition)) return;
+      throw new Error(`Port forward ${definition.forwardId} already exists with different settings.`);
+    }
+    const occupyingId = this.forwardByBrowserPort.get(definition.browserPort);
+    if (occupyingId) throw new Error(`Browser port ${definition.browserPort} is already used by forward ${occupyingId}.`);
+    const active = { definition: { ...definition }, servers: [], relays: /* @__PURE__ */ new Set() };
+    const accept = (socket) => this.acceptConnection(active, socket);
+    const ipv4 = net.createServer({ allowHalfOpen: true }, accept);
+    const ipv6 = net.createServer({ allowHalfOpen: true }, accept);
+    const servers = [ipv4, ipv6];
+    active.servers = servers;
+    try {
+      await listen(ipv4, definition.browserPort, "127.0.0.1");
+      await listen(ipv6, definition.browserPort, "::1", true);
+    } catch (error) {
+      await Promise.all(servers.map(closeServer));
+      throw new Error(
+        `Could not bind localhost:${definition.browserPort}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    this.forwards.set(definition.forwardId, active);
+    this.forwardByBrowserPort.set(definition.browserPort, definition.forwardId);
+  }
+  async stopNow(forwardId) {
+    const active = this.forwards.get(forwardId);
+    if (!active) return;
+    this.forwards.delete(forwardId);
+    this.forwardByBrowserPort.delete(active.definition.browserPort);
+    for (const connection of active.relays) {
+      connection.socket.destroy();
+      connection.relay.close(1e3, "Port forward stopped");
+    }
+    active.relays.clear();
+    await Promise.all(active.servers.map(closeServer));
+  }
+  acceptConnection(active, socket) {
+    socket.pause();
+    socket.setNoDelay(true);
+    const relayConnectionId = crypto.randomUUID();
+    const relay = new WebSocket(relayUrl(this.baseUrl, this.instanceId, active.definition.forwardId, relayConnectionId), {
+      headers: { Authorization: `Bearer ${this.token}` },
+      perMessageDeflate: false
+    });
+    const connection = { socket, relay };
+    active.relays.add(connection);
+    let ready = false;
+    const pendingChunks = [];
+    let pendingBytes = 0;
+    let resumeTimer;
+    let closing = false;
+    const cleanup = () => {
+      if (closing) return;
+      closing = true;
+      if (resumeTimer) clearInterval(resumeTimer);
+      active.relays.delete(connection);
+      socket.destroy();
+      if (relay.readyState === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING) relay.close();
+    };
+    const waitForRelayDrain = () => {
+      if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
+      socket.pause();
+      resumeTimer = setInterval(() => {
+        if (relay.readyState !== WebSocket.OPEN) return cleanup();
+        if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
+        clearInterval(resumeTimer);
+        resumeTimer = void 0;
+        if (ready) socket.resume();
+      }, 10);
+    };
+    const sendChunk = (chunk) => {
+      for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
+        relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
+      }
+      waitForRelayDrain();
+    };
+    relay.on("message", (data, isBinary) => {
+      if (!isBinary) {
+        let control;
+        try {
+          control = JSON.parse(rawDataBuffer(data).toString("utf8"));
+        } catch {
+          return cleanup();
+        }
+        if (control.type === "ready") {
+          ready = true;
+          for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+          pendingBytes = 0;
+          socket.resume();
+        } else if (control.type === "end") {
+          socket.end();
+        } else if (control.type === "error") {
+          socket.destroy(new Error(control.error || "Port-forward relay failed."));
+        }
+        return;
+      }
+      if (!socket.write(rawDataBuffer(data))) {
+        relay.pause();
+        socket.once("drain", () => relay.resume());
+      }
+    });
+    relay.once("error", cleanup);
+    relay.once("close", cleanup);
+    socket.on("data", (chunk) => {
+      if (!ready || relay.readyState !== WebSocket.OPEN) {
+        pendingBytes += chunk.byteLength;
+        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
+        pendingChunks.push(Buffer.from(chunk));
+        socket.pause();
+        return;
+      }
+      sendChunk(chunk);
+    });
+    socket.on("end", () => {
+      if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "end" }));
+    });
+    socket.on("error", (error) => {
+      if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "error", error: error.message }));
+    });
+    socket.on("close", cleanup);
+    socket.pause();
+  }
+}
+export {
+  BrowserPortForwardManager
+};

package/dist/types/port-forward-manager.d.ts

@@ -0,0 +1,23 @@
+export type BrowserPortForwardDefinition = {
+    forwardId: string;
+    workerLabel: string;
+    workerPort: number;
+    browserPort: number;
+};
+export declare class BrowserPortForwardManager {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly instanceId;
+    private readonly forwards;
+    private readonly forwardByBrowserPort;
+    private operationQueue;
+    constructor(baseUrl: string, token: string, instanceId: string);
+    list(): BrowserPortForwardDefinition[];
+    start(definition: BrowserPortForwardDefinition): Promise<void>;
+    stop(forwardId: string): Promise<void>;
+    close(): Promise<void>;
+    private enqueue;
+    private startNow;
+    private stopNow;
+    private acceptConnection;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-browser",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",