sandboxedjs 0.2.4 → 0.2.6

package/dist/python-abi.cjs

@@ -1653,8 +1653,12 @@ function createHostAbiServer(proc) {
       }
       case Op.resolve: {
         const sockets = proc.sockets;
+        const name = r.string();
+        if (/^(\d{1,3}\.){3}\d{1,3}$/.test(name)) {
+          return { status: 0, payload: new Writer().string(name).finish() };
+        }
         if (!sockets?.outbound) throw new PosixError(Errno.ENOSYS);
-        const address = sockets.outbound.resolve(r.string());
+        const address = sockets.outbound.resolve(name);
         return { status: 0, payload: new Writer().string(address).finish() };
       }
       case Op.send: {

package/dist/python-abi.d.cts

@@ -1,6 +1,6 @@
-import { V as Vfs, C as Cred, a as VirtualTcpNetwork } from './contracts-CXZ_25-O.cjs';
-export { m as ROOT_CRED, v as makeCred } from './contracts-CXZ_25-O.cjs';
-export { M as MemoryVolume } from './memory-volume-Bp71nqvc.cjs';
+import { V as Vfs, C as Cred, a as VirtualTcpNetwork } from './contracts-BHo4LdY2.cjs';
+export { m as ROOT_CRED, v as makeCred } from './contracts-BHo4LdY2.cjs';
+export { M as MemoryVolume } from './memory-volume-e-uJFRnG.cjs';
 
 /**
  * Open-file descriptions: the thing a descriptor points *at*.

package/dist/python-abi.d.ts

@@ -1,6 +1,6 @@
-import { V as Vfs, C as Cred, a as VirtualTcpNetwork } from './contracts-CXZ_25-O.js';
-export { m as ROOT_CRED, v as makeCred } from './contracts-CXZ_25-O.js';
-export { M as MemoryVolume } from './memory-volume-C4xwtIRZ.js';
+import { V as Vfs, C as Cred, a as VirtualTcpNetwork } from './contracts-BHo4LdY2.js';
+export { m as ROOT_CRED, v as makeCred } from './contracts-BHo4LdY2.js';
+export { M as MemoryVolume } from './memory-volume-meoRW8ST.js';
 
 /**
  * Open-file descriptions: the thing a descriptor points *at*.

package/dist/python-abi.js

@@ -1651,8 +1651,12 @@ function createHostAbiServer(proc) {
       }
       case Op.resolve: {
         const sockets = proc.sockets;
+        const name = r.string();
+        if (/^(\d{1,3}\.){3}\d{1,3}$/.test(name)) {
+          return { status: 0, payload: new Writer().string(name).finish() };
+        }
         if (!sockets?.outbound) throw new PosixError(Errno.ENOSYS);
-        const address = sockets.outbound.resolve(r.string());
+        const address = sockets.outbound.resolve(name);
         return { status: 0, payload: new Writer().string(address).finish() };
       }
       case Op.send: {

package/dist/service-worker.js

@@ -1,3 +1,58 @@
+// src/preview/fetch-client.ts
+function installPreviewFetch(scope) {
+  const MARKER = "__sbx__/";
+  const at = scope.location.pathname.indexOf(MARKER);
+  if (at < 0) return;
+  const base = scope.location.origin + scope.location.pathname.slice(0, at + MARKER.length);
+  const LOOPBACK = /^(?:localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[?::1\]?|[^.]+\.localhost)$/i;
+  const rewrite = (value) => {
+    let url;
+    try {
+      url = new URL(value, scope.location.href);
+    } catch {
+      return value;
+    }
+    const secure = url.protocol === "https:" || url.protocol === "wss:";
+    if (!secure && url.protocol !== "http:" && url.protocol !== "ws:") return value;
+    if (!LOOPBACK.test(url.hostname)) return value;
+    const port = url.port || (secure ? "443" : "80");
+    return `${base}${port}${url.pathname}${url.search}${url.hash}`;
+  };
+  const originalFetch = scope.fetch;
+  if (typeof originalFetch === "function") {
+    scope.fetch = function patched(input, init) {
+      if (typeof input === "string" || input instanceof URL) {
+        return originalFetch.call(this, rewrite(String(input)), init);
+      }
+      const moved = input && typeof input === "object" && "url" in input ? rewrite(input.url) : null;
+      if (moved === null || moved === input.url) {
+        return originalFetch.call(this, input, init);
+      }
+      return originalFetch.call(this, new Request(moved, input), init);
+    };
+  }
+  const open = scope.XMLHttpRequest?.prototype?.open;
+  if (typeof open === "function") {
+    scope.XMLHttpRequest.prototype.open = function patched(method, url, ...rest) {
+      return open.call(this, method, rewrite(String(url)), ...rest);
+    };
+  }
+  const OriginalEventSource = scope.EventSource;
+  if (typeof OriginalEventSource === "function") {
+    const Patched = function(url, init) {
+      return new OriginalEventSource(rewrite(String(url)), init);
+    };
+    Patched.prototype = OriginalEventSource.prototype;
+    for (const name of ["CONNECTING", "OPEN", "CLOSED"]) {
+      Object.defineProperty(Patched, name, { value: OriginalEventSource[name], enumerable: true });
+    }
+    scope.EventSource = Patched;
+  }
+}
+function previewFetchSource() {
+  return `(function(){try{(${installPreviewFetch.toString()})(window);}catch(error){console.warn("sandboxedjs: loopback rewriting unavailable",error);}})();`;
+}
+
 // src/preview/ws-client.ts
 function installPreviewSockets(scope) {
   const Native = scope.WebSocket;
@@ -419,6 +474,19 @@ var PreviewRouter = class {
   portFor(clientId) {
     return this.clientPorts.get(clientId);
   }
+  /**
+   * The container port one request is for, by path first and client second.
+   *
+   * A port named in the path wins, because that is how a previewed page
+   * reaches its *other* servers: the frontend's document is bound to 3000, and
+   * its call to the backend arrives as `__sbx__/8000/…`. Reading the port from
+   * the path also means such a request needs nothing remembered about who is
+   * asking — which matters, because this worker is stopped whenever it looks
+   * idle and every binding it held is gone when it starts again.
+   */
+  portForRequest(pathname, clientId) {
+    return this.claimedPort(pathname) ?? this.portFor(clientId);
+  }
   /** A response has come back from the page. */
   settle(id, response) {
     const resolve = this.pending.get(id);
@@ -498,7 +566,7 @@ function withSockets(body, headers) {
   const encoding = headers.get("content-encoding");
   if (encoding && encoding.toLowerCase() !== "identity") return body;
   const html = new TextDecoder().decode(body);
-  const tag = `<script>${previewSocketSource()}<\/script>`;
+  const tag = `<script>${previewSocketSource()}${previewFetchSource()}<\/script>`;
   const head = /<head[^>]*>/i.exec(html);
   const at = head ? head.index + head[0].length : 0;
   const bytes = new TextEncoder().encode(html.slice(0, at) + tag + html.slice(at));
@@ -591,7 +659,7 @@ worker.addEventListener("fetch", (event) => {
     event.respondWith(router.fetch(claimed, "/", event.request, event.resultingClientId || event.clientId));
     return;
   }
-  const port = router.portFor(event.clientId);
+  const port = router.portForRequest(url.pathname, event.clientId);
   if (port === void 0) return;
   event.respondWith(
     router.fetch(port, router.containerPath(url.pathname, url.search), event.request, event.clientId)

package/dist/worker-entry.js

@@ -28231,6 +28231,60 @@ var url_module_default = urlModule;
 var import_events = __toESM(require_events());
 var import_stream_browserify3 = __toESM(require_stream_browserify());
 
+// src/net/proxy-fetch.ts
+function toBase64(bytes2) {
+  let text = "";
+  for (let at2 = 0; at2 < bytes2.length; at2 += 32768) {
+    text += String.fromCharCode(...bytes2.subarray(at2, at2 + 32768));
+  }
+  return btoa(text);
+}
+function fromBase64(text) {
+  const binary = atob(text);
+  const bytes2 = new Uint8Array(binary.length);
+  for (let at2 = 0; at2 < binary.length; at2 += 1) bytes2[at2] = binary.charCodeAt(at2);
+  return bytes2;
+}
+async function proxyExchange(proxy, request, fetchImpl = fetch) {
+  let answer2;
+  try {
+    answer2 = await fetchImpl(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        url: request.url,
+        method: request.method,
+        headers: request.headers,
+        ...request.body?.length ? { body: toBase64(request.body) } : {}
+      })
+    });
+  } catch (error) {
+    throw new Error(
+      `the egress proxy at ${proxy} could not be reached (${error instanceof Error ? error.message : String(error)}). It performs this container's outbound requests, so nothing leaves until it answers.`
+    );
+  }
+  if (!answer2.ok) {
+    throw new Error(
+      `the egress proxy at ${proxy} refused ${request.method} ${request.url} with ${answer2.status} ${answer2.statusText}: ${(await answer2.text()).trim().slice(0, 300)}`
+    );
+  }
+  const payload = await answer2.json();
+  return {
+    status: payload.status ?? 200,
+    statusText: payload.statusText ?? "",
+    headers: payload.headers ?? {},
+    body: payload.body ? fromBase64(payload.body) : new Uint8Array(0)
+  };
+}
+function isBrowser() {
+  return typeof process === "undefined" || process.versions?.node == null;
+}
+function browserBlocked(hostname, message) {
+  return new Error(
+    `${message} \u2014 the request to ${hostname} was blocked by the browser. A page can only read a response from a host that sends CORS headers, and most APIs send none. Give the container a proxy that makes the request for it \u2014 network: { proxy }, and \`npx sandboxedjs-egress\` is one \u2014 or run the container on a server.`
+  );
+}
+
 // src/net/policy.ts
 function isLoopbackHostname(hostname) {
   const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
@@ -28273,7 +28327,40 @@ function policedFetch(policy, fetchImpl) {
     if (!outboundAllowed(policy, url)) {
       throw Object.assign(new TypeError("fetch failed"), { cause: outboundBlockedError(url) });
     }
-    return fetchImpl(input, init);
+    if (policy.proxy) return await fetchThroughProxy(policy.proxy, fetchImpl, input, init);
+    try {
+      return await fetchImpl(input, init);
+    } catch (error) {
+      if (!isBrowser()) throw error;
+      throw Object.assign(new TypeError("fetch failed"), {
+        cause: browserBlocked(new URL(url).hostname, error instanceof Error ? error.message : String(error))
+      });
+    }
+  });
+}
+async function fetchThroughProxy(proxy, fetchImpl, input, init) {
+  const request = new Request(input, init);
+  const headers = {};
+  request.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  const bodyless = request.method === "GET" || request.method === "HEAD";
+  const result = await proxyExchange(
+    proxy,
+    {
+      url: request.url,
+      method: request.method,
+      headers,
+      ...bodyless ? {} : { body: new Uint8Array(await request.arrayBuffer()) }
+    },
+    fetchImpl
+  );
+  const nullBody = result.status === 204 || result.status === 205 || result.status === 304 || request.method === "HEAD";
+  const body = nullBody ? null : result.body.slice().buffer;
+  return new Response(body, {
+    status: result.status,
+    statusText: result.statusText,
+    headers: result.headers
   });
 }
 function policedWebSocket(Native, policy) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandboxedjs",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A Linux-like container that runs entirely inside Node.js — POSIX shell, ~140 coreutils, Node.js and Python runtimes, virtual filesystem and networking. No Docker, no VM, no native modules.",
   "type": "module",
   "license": "MIT",
@@ -31,6 +31,11 @@
       "import": "./dist/agent.js",
       "require": "./dist/agent.cjs"
     },
+    "./egress": {
+      "types": "./dist/egress.d.ts",
+      "import": "./dist/egress.js",
+      "require": "./dist/egress.cjs"
+    },
     "./browser-host": {
       "types": "./dist/browser-host.d.ts",
       "import": "./dist/browser-host.js",