@ricsam/r5d-worker 0.0.69 → 0.0.71

package/dist/cjs/main.cjs

@@ -2296,7 +2296,10 @@ function resolveHostShell(command, platform = process.platform) {
     return /(?:^|[\\/])cmd\.exe$/i.test(file2) ? { file: file2, args: ["/d", "/s", "/c", command] } : { file: file2, args: ["-Command", command] };
   }
   const file = process.env.SHELL || "/bin/bash";
-  return { file, args: command === void 0 ? ["-l"] : ["-lc", command] };
+  if (command === void 0) {
+    return { file, args: ["-l"] };
+  }
+  return { file, args: ["-lc", 'eval "$R5D_SHELL_COMMAND"'], env: { R5D_SHELL_COMMAND: command } };
 }
 async function openPty(input) {
   if (activePtys.has(input.message.ptyId)) {
@@ -2331,7 +2334,8 @@ async function openPty(input) {
         ...githubProcessEnv(),
         ...input.message.env ?? {},
         ...planProcessEnv,
-        ...targetProcessEnv
+        ...targetProcessEnv,
+        ...shell.env ?? {}
       }
     },
     onOpened: () => {

package/dist/cjs/package.json

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

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

@@ -36,6 +36,7 @@ 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;
+const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
 function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
   const url = new URL("/worker/port-forward/ws", baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
@@ -44,42 +45,59 @@ function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
   url.searchParams.set("connection", relayConnectionId);
   return url.toString();
 }
+function loopbackAddress(host, port) {
+  return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
+}
 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 socket;
   let relayReady = false;
   let targetReady = false;
+  let targetEndRequested = false;
+  let targetFailure;
   const pendingChunks = [];
   let pendingBytes = 0;
+  const pendingWrites = [];
+  let pendingWriteBytes = 0;
   let closing = false;
   let resumeTimer;
   const maybeResume = () => {
-    if (relayReady && targetReady && !resumeTimer) socket.resume();
+    if (relayReady && targetReady && !resumeTimer) socket?.resume();
   };
   const cleanup = () => {
     if (closing) return;
     closing = true;
     if (resumeTimer) clearInterval(resumeTimer);
-    socket.destroy();
+    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 }));
+    if (closing) return;
+    const payload = JSON.stringify({ type: "error", error: message });
+    if (relay.readyState === import_ws.default.CONNECTING) {
+      closing = true;
+      if (resumeTimer) clearInterval(resumeTimer);
+      socket?.destroy();
+      relay.once("open", () => {
+        relay.send(payload);
+        relay.close();
+      });
+      return;
+    }
+    if (relay.readyState === import_ws.default.OPEN) relay.send(payload);
     cleanup();
   };
   const waitForRelayDrain = () => {
     if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-    socket.pause();
+    socket?.pause();
     resumeTimer = setInterval(() => {
       if (relay.readyState !== import_ws.default.OPEN) return cleanup();
       if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
@@ -94,25 +112,53 @@ function openWorkerPortForwardRelay(options) {
     }
     waitForRelayDrain();
   };
-  socket.once("connect", () => {
+  const adoptTarget = (target, host) => {
+    if (closing) return target.destroy();
+    socket = target;
+    target.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));
+        target.pause();
+        return;
+      }
+      sendChunk(chunk);
+    });
+    target.on("end", () => {
+      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "end" }));
+    });
+    target.on("error", (error) => sendError(`Connection to ${loopbackAddress(host, options.workerPort)} failed: ${error.message}`));
+    target.on("close", cleanup);
+    target.pause();
     targetReady = true;
+    for (const chunk of pendingWrites.splice(0)) target.write(chunk);
+    pendingWriteBytes = 0;
+    if (targetFailure) return void target.destroy(targetFailure);
+    if (targetEndRequested) target.end();
     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);
+  };
+  const dialFailures = [];
+  const dialTarget = (host, fallbackHosts2) => {
+    if (closing) return;
+    const candidate = import_node_net.default.createConnection({ host, port: options.workerPort, allowHalfOpen: true });
+    candidate.pause();
+    candidate.setNoDelay(true);
+    const onDialError = (error) => {
+      candidate.destroy();
+      dialFailures.push(`${loopbackAddress(host, options.workerPort)} (${error.code ?? error.message})`);
+      const [nextHost, ...rest] = fallbackHosts2;
+      if (nextHost) return dialTarget(nextHost, rest);
+      sendError(
+        `Could not connect to ${dialFailures.join(" or ")} on the worker. Nothing is listening on either loopback address for port ${options.workerPort} \u2014 make sure the server is running and bound to a loopback or wildcard host.`
+      );
+    };
+    candidate.once("error", onDialError);
+    candidate.once("connect", () => {
+      candidate.off("error", onDialError);
+      adoptTarget(candidate, host);
+    });
+  };
   relay.on("message", (data, isBinary) => {
     if (!isBinary) {
       let control;
@@ -123,24 +169,36 @@ function openWorkerPortForwardRelay(options) {
       }
       if (control.type === "ready") {
         relayReady = true;
-        for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+        for (const chunk2 of pendingChunks.splice(0)) sendChunk(chunk2);
         pendingBytes = 0;
         maybeResume();
       } else if (control.type === "end") {
-        socket.end();
+        if (socket) socket.end();
+        else targetEndRequested = true;
       } else if (control.type === "error") {
-        socket.destroy(new Error(control.error || "Port-forward relay failed."));
+        const failure = new Error(control.error || "Port-forward relay failed.");
+        if (socket) socket.destroy(failure);
+        else targetFailure = failure;
       }
       return;
     }
-    if (!socket.write(rawDataBuffer(data))) {
+    const chunk = rawDataBuffer(data);
+    if (!socket) {
+      pendingWriteBytes += chunk.byteLength;
+      if (pendingWriteBytes > RELAY_PAUSE_BYTES) return cleanup();
+      pendingWrites.push(Buffer.from(chunk));
+      return;
+    }
+    const target = socket;
+    if (!target.write(chunk)) {
       relay.pause();
-      socket.once("drain", () => relay.resume());
+      target.once("drain", () => relay.resume());
     }
   });
   relay.on("error", cleanup);
   relay.once("close", cleanup);
-  socket.pause();
+  const [primaryHost, ...fallbackHosts] = LOOPBACK_HOSTS;
+  dialTarget(primaryHost, fallbackHosts);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/mjs/main.mjs

@@ -2267,7 +2267,10 @@ function resolveHostShell(command, platform = process.platform) {
     return /(?:^|[\\/])cmd\.exe$/i.test(file2) ? { file: file2, args: ["/d", "/s", "/c", command] } : { file: file2, args: ["-Command", command] };
   }
   const file = process.env.SHELL || "/bin/bash";
-  return { file, args: command === void 0 ? ["-l"] : ["-lc", command] };
+  if (command === void 0) {
+    return { file, args: ["-l"] };
+  }
+  return { file, args: ["-lc", 'eval "$R5D_SHELL_COMMAND"'], env: { R5D_SHELL_COMMAND: command } };
 }
 async function openPty(input) {
   if (activePtys.has(input.message.ptyId)) {
@@ -2302,7 +2305,8 @@ async function openPty(input) {
         ...githubProcessEnv(),
         ...input.message.env ?? {},
         ...planProcessEnv,
-        ...targetProcessEnv
+        ...targetProcessEnv,
+        ...shell.env ?? {}
       }
     },
     onOpened: () => {

package/dist/mjs/package.json

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

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

@@ -3,6 +3,7 @@ import WebSocket, {} from "ws";
 const RELAY_FRAME_BYTES = 64 * 1024;
 const RELAY_PAUSE_BYTES = 1024 * 1024;
 const RELAY_RESUME_BYTES = 256 * 1024;
+const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
 function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
   const url = new URL("/worker/port-forward/ws", baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
@@ -11,42 +12,59 @@ function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
   url.searchParams.set("connection", relayConnectionId);
   return url.toString();
 }
+function loopbackAddress(host, port) {
+  return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
+}
 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 socket;
   let relayReady = false;
   let targetReady = false;
+  let targetEndRequested = false;
+  let targetFailure;
   const pendingChunks = [];
   let pendingBytes = 0;
+  const pendingWrites = [];
+  let pendingWriteBytes = 0;
   let closing = false;
   let resumeTimer;
   const maybeResume = () => {
-    if (relayReady && targetReady && !resumeTimer) socket.resume();
+    if (relayReady && targetReady && !resumeTimer) socket?.resume();
   };
   const cleanup = () => {
     if (closing) return;
     closing = true;
     if (resumeTimer) clearInterval(resumeTimer);
-    socket.destroy();
+    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 }));
+    if (closing) return;
+    const payload = JSON.stringify({ type: "error", error: message });
+    if (relay.readyState === WebSocket.CONNECTING) {
+      closing = true;
+      if (resumeTimer) clearInterval(resumeTimer);
+      socket?.destroy();
+      relay.once("open", () => {
+        relay.send(payload);
+        relay.close();
+      });
+      return;
+    }
+    if (relay.readyState === WebSocket.OPEN) relay.send(payload);
     cleanup();
   };
   const waitForRelayDrain = () => {
     if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-    socket.pause();
+    socket?.pause();
     resumeTimer = setInterval(() => {
       if (relay.readyState !== WebSocket.OPEN) return cleanup();
       if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
@@ -61,25 +79,53 @@ function openWorkerPortForwardRelay(options) {
     }
     waitForRelayDrain();
   };
-  socket.once("connect", () => {
+  const adoptTarget = (target, host) => {
+    if (closing) return target.destroy();
+    socket = target;
+    target.on("data", (chunk) => {
+      if (!relayReady || relay.readyState !== WebSocket.OPEN) {
+        pendingBytes += chunk.byteLength;
+        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
+        pendingChunks.push(Buffer.from(chunk));
+        target.pause();
+        return;
+      }
+      sendChunk(chunk);
+    });
+    target.on("end", () => {
+      if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "end" }));
+    });
+    target.on("error", (error) => sendError(`Connection to ${loopbackAddress(host, options.workerPort)} failed: ${error.message}`));
+    target.on("close", cleanup);
+    target.pause();
     targetReady = true;
+    for (const chunk of pendingWrites.splice(0)) target.write(chunk);
+    pendingWriteBytes = 0;
+    if (targetFailure) return void target.destroy(targetFailure);
+    if (targetEndRequested) target.end();
     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);
+  };
+  const dialFailures = [];
+  const dialTarget = (host, fallbackHosts2) => {
+    if (closing) return;
+    const candidate = net.createConnection({ host, port: options.workerPort, allowHalfOpen: true });
+    candidate.pause();
+    candidate.setNoDelay(true);
+    const onDialError = (error) => {
+      candidate.destroy();
+      dialFailures.push(`${loopbackAddress(host, options.workerPort)} (${error.code ?? error.message})`);
+      const [nextHost, ...rest] = fallbackHosts2;
+      if (nextHost) return dialTarget(nextHost, rest);
+      sendError(
+        `Could not connect to ${dialFailures.join(" or ")} on the worker. Nothing is listening on either loopback address for port ${options.workerPort} \u2014 make sure the server is running and bound to a loopback or wildcard host.`
+      );
+    };
+    candidate.once("error", onDialError);
+    candidate.once("connect", () => {
+      candidate.off("error", onDialError);
+      adoptTarget(candidate, host);
+    });
+  };
   relay.on("message", (data, isBinary) => {
     if (!isBinary) {
       let control;
@@ -90,24 +136,36 @@ function openWorkerPortForwardRelay(options) {
       }
       if (control.type === "ready") {
         relayReady = true;
-        for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
+        for (const chunk2 of pendingChunks.splice(0)) sendChunk(chunk2);
         pendingBytes = 0;
         maybeResume();
       } else if (control.type === "end") {
-        socket.end();
+        if (socket) socket.end();
+        else targetEndRequested = true;
       } else if (control.type === "error") {
-        socket.destroy(new Error(control.error || "Port-forward relay failed."));
+        const failure = new Error(control.error || "Port-forward relay failed.");
+        if (socket) socket.destroy(failure);
+        else targetFailure = failure;
       }
       return;
     }
-    if (!socket.write(rawDataBuffer(data))) {
+    const chunk = rawDataBuffer(data);
+    if (!socket) {
+      pendingWriteBytes += chunk.byteLength;
+      if (pendingWriteBytes > RELAY_PAUSE_BYTES) return cleanup();
+      pendingWrites.push(Buffer.from(chunk));
+      return;
+    }
+    const target = socket;
+    if (!target.write(chunk)) {
       relay.pause();
-      socket.once("drain", () => relay.resume());
+      target.once("drain", () => relay.resume());
     }
   });
   relay.on("error", cleanup);
   relay.once("close", cleanup);
-  socket.pause();
+  const [primaryHost, ...fallbackHosts] = LOOPBACK_HOSTS;
+  dialTarget(primaryHost, fallbackHosts);
 }
 export {
   openWorkerPortForwardRelay

package/dist/types/main.d.ts

@@ -209,5 +209,6 @@ export declare function prepareShellEnvForTarget(input: {
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];
+    env?: Record<string, string>;
 };
 export {};

package/package.json

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