@ricsam/r5d-worker 0.0.47 → 0.0.48

package/README.md

@@ -37,3 +37,5 @@ The agent runs commands through the virtual shell command:
 worker exec macos docker compose up -d
 worker exec macos bun test
 ```
+
+When the connected `r5d-browser` requests a port forward, the worker opens each relayed connection only to `127.0.0.1` on the requested worker port. Browser-side and worker-side ports may differ. The worker never opens a public listener, and a disconnected worker leaves the browser's long-lived mapping unavailable until the same worker label reconnects.

package/dist/cjs/main.cjs

@@ -58,6 +58,7 @@ var import_cli_update = require("./cli-update.cjs");
 var import_git_identity = require("./git-identity.cjs");
 var import_heartbeat = require("./heartbeat.cjs");
 var import_process_tree = require("./process-tree.cjs");
+var import_port_forward_client = require("./port-forward-client.cjs");
 var import_supervisor = require("./supervisor.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
 var import_workspace_sync = require("./workspace-sync.cjs");
@@ -2568,7 +2569,8 @@ async function startWorker(options) {
         r5dctlVersion: (0, import_cli_update.readInstalledCliVersion)("r5dctl"),
         capabilities: {
           updateClis: true,
-          canonicalResolverCheckout: true
+          canonicalResolverCheckout: true,
+          browserPortForwarding: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -2721,6 +2723,17 @@ async function startWorker(options) {
         pendingProcessTerminals.delete(message.runId);
         return;
       }
+      if (message.type === "port_forward_connect") {
+        (0, import_port_forward_client.openWorkerPortForwardRelay)({
+          baseUrl,
+          token,
+          label,
+          forwardId: message.forwardId,
+          relayConnectionId: message.relayConnectionId,
+          workerPort: message.workerPort
+        });
+        return;
+      }
       if (message.type === "update_clis") {
         if (cliUpdateInProgress) {
           sendWorkerMessage(ws, {

package/dist/cjs/package.json

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

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

@@ -0,0 +1,148 @@
+"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_client_exports = {};
+__export(port_forward_client_exports, {
+  openWorkerPortForwardRelay: () => openWorkerPortForwardRelay
+});
+module.exports = __toCommonJS(port_forward_client_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, label, forwardId, relayConnectionId) {
+  const url = new URL("/worker/port-forward/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("label", label);
+  url.searchParams.set("forward", forwardId);
+  url.searchParams.set("connection", relayConnectionId);
+  return url.toString();
+}
+function rawDataBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (Array.isArray(data)) return Buffer.concat(data);
+  return Buffer.from(data);
+}
+function openWorkerPortForwardRelay(options) {
+  const socket = import_node_net.default.createConnection({ host: "127.0.0.1", port: options.workerPort, allowHalfOpen: true });
+  socket.pause();
+  socket.setNoDelay(true);
+  const relay = new import_ws.default(relayUrl(options.baseUrl, options.label, options.forwardId, options.relayConnectionId), {
+    headers: { Authorization: `Bearer ${options.token}` },
+    perMessageDeflate: false
+  });
+  let relayReady = false;
+  let targetReady = false;
+  const pendingChunks = [];
+  let pendingBytes = 0;
+  let closing = false;
+  let resumeTimer;
+  const maybeResume = () => {
+    if (relayReady && targetReady && !resumeTimer) socket.resume();
+  };
+  const cleanup = () => {
+    if (closing) return;
+    closing = true;
+    if (resumeTimer) clearInterval(resumeTimer);
+    socket.destroy();
+    if (relay.readyState === import_ws.default.OPEN || relay.readyState === import_ws.default.CONNECTING) relay.close();
+  };
+  const sendError = (message) => {
+    if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "error", error: message }));
+    cleanup();
+  };
+  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;
+      maybeResume();
+    }, 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();
+  };
+  socket.once("connect", () => {
+    targetReady = true;
+    maybeResume();
+  });
+  socket.on("data", (chunk) => {
+    if (!relayReady || 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) => sendError(`Could not connect to 127.0.0.1:${options.workerPort}: ${error.message}`));
+  socket.on("close", cleanup);
+  relay.on("message", (data, isBinary) => {
+    if (!isBinary) {
+      let control;
+      try {
+        control = JSON.parse(rawDataBuffer(data).toString("utf8"));
+      } catch {
+        return cleanup();
+      }
+      if (control.type === "ready") {
+        relayReady = true;
+        for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+        pendingBytes = 0;
+        maybeResume();
+      } 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.pause();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openWorkerPortForwardRelay
+});

package/dist/mjs/main.mjs

@@ -8,6 +8,7 @@ import { installCliUpdate, readInstalledCliVersion } from "./cli-update.mjs";
 import { configureVisibleGitIdentity } from "./git-identity.mjs";
 import { hasWorkerHeartbeatTimedOut, WORKER_HEARTBEAT_INTERVAL_MS } from "./heartbeat.mjs";
 import { terminateProcessTree } from "./process-tree.mjs";
+import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
 import {
   isRetryableWorkerServerStatus,
   superviseWorkerRuntime,
@@ -2530,7 +2531,8 @@ async function startWorker(options) {
         r5dctlVersion: readInstalledCliVersion("r5dctl"),
         capabilities: {
           updateClis: true,
-          canonicalResolverCheckout: true
+          canonicalResolverCheckout: true,
+          browserPortForwarding: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -2683,6 +2685,17 @@ async function startWorker(options) {
         pendingProcessTerminals.delete(message.runId);
         return;
       }
+      if (message.type === "port_forward_connect") {
+        openWorkerPortForwardRelay({
+          baseUrl,
+          token,
+          label,
+          forwardId: message.forwardId,
+          relayConnectionId: message.relayConnectionId,
+          workerPort: message.workerPort
+        });
+        return;
+      }
       if (message.type === "update_clis") {
         if (cliUpdateInProgress) {
           sendWorkerMessage(ws, {

package/dist/mjs/package.json

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

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

@@ -0,0 +1,114 @@
+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, label, forwardId, relayConnectionId) {
+  const url = new URL("/worker/port-forward/ws", baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("label", label);
+  url.searchParams.set("forward", forwardId);
+  url.searchParams.set("connection", relayConnectionId);
+  return url.toString();
+}
+function rawDataBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (Array.isArray(data)) return Buffer.concat(data);
+  return Buffer.from(data);
+}
+function openWorkerPortForwardRelay(options) {
+  const socket = net.createConnection({ host: "127.0.0.1", port: options.workerPort, allowHalfOpen: true });
+  socket.pause();
+  socket.setNoDelay(true);
+  const relay = new WebSocket(relayUrl(options.baseUrl, options.label, options.forwardId, options.relayConnectionId), {
+    headers: { Authorization: `Bearer ${options.token}` },
+    perMessageDeflate: false
+  });
+  let relayReady = false;
+  let targetReady = false;
+  const pendingChunks = [];
+  let pendingBytes = 0;
+  let closing = false;
+  let resumeTimer;
+  const maybeResume = () => {
+    if (relayReady && targetReady && !resumeTimer) socket.resume();
+  };
+  const cleanup = () => {
+    if (closing) return;
+    closing = true;
+    if (resumeTimer) clearInterval(resumeTimer);
+    socket.destroy();
+    if (relay.readyState === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING) relay.close();
+  };
+  const sendError = (message) => {
+    if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "error", error: message }));
+    cleanup();
+  };
+  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;
+      maybeResume();
+    }, 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();
+  };
+  socket.once("connect", () => {
+    targetReady = true;
+    maybeResume();
+  });
+  socket.on("data", (chunk) => {
+    if (!relayReady || 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) => sendError(`Could not connect to 127.0.0.1:${options.workerPort}: ${error.message}`));
+  socket.on("close", cleanup);
+  relay.on("message", (data, isBinary) => {
+    if (!isBinary) {
+      let control;
+      try {
+        control = JSON.parse(rawDataBuffer(data).toString("utf8"));
+      } catch {
+        return cleanup();
+      }
+      if (control.type === "ready") {
+        relayReady = true;
+        for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+        pendingBytes = 0;
+        maybeResume();
+      } 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.pause();
+}
+export {
+  openWorkerPortForwardRelay
+};

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

@@ -0,0 +1,8 @@
+export declare function openWorkerPortForwardRelay(options: {
+    baseUrl: string;
+    token: string;
+    label: string;
+    forwardId: string;
+    relayConnectionId: string;
+    workerPort: number;
+}): void;

package/package.json

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