peachsim 0.1.527

package/dist-lib/host/fetch-proxy-handler.cjs

@@ -0,0 +1,421 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"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);
+
+// src/host/fetch-proxy-handler.ts
+var fetch_proxy_handler_exports = {};
+__export(fetch_proxy_handler_exports, {
+  buildAppApiProxyHeaders: () => buildAppApiProxyHeaders,
+  buildFetchProxyHeaders: () => buildFetchProxyHeaders,
+  handleAppApiRequest: () => handleAppApiRequest,
+  handleBundleProxyRequest: () => handleBundleProxyRequest,
+  handleFetchProxyRequest: () => handleFetchProxyRequest,
+  isAppApiRequestUrl: () => isAppApiRequestUrl,
+  isBundleProxyRequestUrl: () => isBundleProxyRequestUrl,
+  isFetchProxyRequestUrl: () => isFetchProxyRequestUrl
+});
+module.exports = __toCommonJS(fetch_proxy_handler_exports);
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+var import_promises = require("stream/promises");
+
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/host/fetch-proxy-overrides.ts
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+
+// src/host/fetch-proxy-handler.ts
+var STRIP_FETCH_PROXY_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "user-agent",
+  "accept-encoding",
+  "cookie",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "content-length",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest",
+  "sec-ch-ua",
+  "sec-ch-ua-mobile",
+  "sec-ch-ua-platform"
+]);
+var FETCH_PROXY_CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET,POST,PUT,DELETE,PATCH,OPTIONS",
+  "access-control-allow-headers": "*",
+  "access-control-expose-headers": "*",
+  "access-control-max-age": "3600"
+};
+var APP_API_HEADER_REWRITES = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest"
+]);
+function loopbackTlsOptions(targetUrl) {
+  if (targetUrl.protocol !== "https:") return {};
+  return isLoopbackHost(targetUrl.hostname) ? { rejectUnauthorized: false } : {};
+}
+function applyFetchProxyCors(res) {
+  for (const [key, value] of Object.entries(FETCH_PROXY_CORS_HEADERS)) {
+    res.setHeader(key, value);
+  }
+}
+function formatFetchProxyError(targetUrl, err) {
+  const details = [];
+  const error = err;
+  if (error?.code) details.push(error.code);
+  if (error?.message) details.push(error.message);
+  if (error?.cause?.code) details.push(error.cause.code);
+  if (error?.cause?.message) details.push(error.cause.message);
+  const uniqueDetails = [...new Set(details.filter(Boolean))];
+  const message = uniqueDetails.join(" | ") || String(err);
+  if (targetUrl.includes("stored-in-.env.local")) {
+    return `${message} | upstream url still contains placeholder env values`;
+  }
+  return message;
+}
+function buildFetchProxyHeaders(reqHeaders, targetUrl) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (STRIP_FETCH_PROXY_HEADERS.has(key.toLowerCase())) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  Object.assign(
+    headers,
+    targetUrl ? getFetchProxyTargetHeaders(targetUrl) : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT }
+  );
+  return headers;
+}
+function buildAppApiProxyHeaders(reqHeaders, targetUrl) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (APP_API_HEADER_REWRITES.has(key.toLowerCase())) continue;
+    headers[key] = value;
+  }
+  headers.host = targetUrl.host;
+  if (!Object.keys(headers).some((name) => name.toLowerCase() === "expo-origin")) {
+    headers.origin = targetUrl.origin;
+    headers.referer = `${targetUrl.origin}/`;
+  }
+  return headers;
+}
+function isFetchProxyRequestUrl(rawUrl) {
+  return rawUrl?.startsWith("/__fetch-proxy?") || rawUrl?.startsWith("/__proxy?") || false;
+}
+function isBundleProxyRequestUrl(rawUrl) {
+  return rawUrl?.startsWith("/__bundle-proxy?") ?? false;
+}
+function isAppApiRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  if (rawUrl.startsWith("/__app-api?")) return true;
+  if (rawUrl.startsWith("/__app-api/")) return true;
+  return false;
+}
+async function handleFetchProxyRequest(req, res) {
+  if (req.method === "OPTIONS") {
+    applyFetchProxyCors(res);
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const params = new URLSearchParams((req.url || "").split("?")[1] || "");
+  const targetUrl = params.get("url");
+  if (!targetUrl) {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("missing url param");
+    return;
+  }
+  let upstreamUrl;
+  try {
+    upstreamUrl = new URL(targetUrl);
+  } catch {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("invalid url param");
+    return;
+  }
+  let body;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length > 0) {
+      body = Buffer.concat(chunks);
+    }
+  }
+  const originalMethod = req.method || "GET";
+  const proxy = async (targetUrl2, method, nextBody, redirects) => {
+    const transport = targetUrl2.protocol === "https:" ? import_https.default : import_http.default;
+    const targetHeaders = buildFetchProxyHeaders(req.headers, targetUrl2);
+    if (targetUrl2.origin !== upstreamUrl.origin) {
+      delete targetHeaders.authorization;
+      delete targetHeaders["proxy-authorization"];
+    }
+    if (method === "GET" || method === "HEAD") {
+      delete targetHeaders["content-length"];
+      delete targetHeaders["content-type"];
+    } else if (nextBody) {
+      targetHeaders["content-length"] = String(nextBody.byteLength);
+    }
+    const proxyRes = await new Promise((resolve, reject) => {
+      const proxyReq = transport.request(
+        {
+          hostname: normalizeHostname(targetUrl2.hostname),
+          port: targetUrl2.port || (targetUrl2.protocol === "https:" ? 443 : 80),
+          path: targetUrl2.pathname + targetUrl2.search,
+          method,
+          headers: targetHeaders,
+          ...loopbackTlsOptions(targetUrl2)
+        },
+        resolve
+      );
+      const abort = () => proxyReq.destroy(new Error("fetch proxy client disconnected"));
+      req.once("aborted", abort);
+      proxyReq.once("close", () => req.off("aborted", abort));
+      proxyReq.once("error", reject);
+      if (nextBody === void 0) proxyReq.end();
+      else proxyReq.end(nextBody);
+    });
+    const status = proxyRes.statusCode ?? 502;
+    const location = proxyRes.headers.location;
+    if (location && (status === 301 || status === 302 || status === 303 || status === 307 || status === 308)) {
+      if (redirects >= 10) {
+        proxyRes.destroy();
+        throw new Error("too many redirects");
+      }
+      const switchToGet = (status === 301 || status === 302) && method === "POST" || status === 303 && method !== "GET" && method !== "HEAD";
+      const redirectUrl = new URL(location, targetUrl2);
+      proxyRes.resume();
+      await (0, import_promises.finished)(proxyRes);
+      await proxy(
+        redirectUrl,
+        switchToGet ? "GET" : method,
+        switchToGet ? void 0 : nextBody,
+        redirects + 1
+      );
+      return;
+    }
+    for (const [key, value] of Object.entries(proxyRes.headers)) {
+      const lowerKey = key.toLowerCase();
+      if (value === void 0 || lowerKey === "set-cookie" || lowerKey === "connection" || lowerKey === "keep-alive" || lowerKey === "proxy-authenticate" || lowerKey === "proxy-authorization" || lowerKey === "te" || lowerKey === "trailer" || lowerKey === "transfer-encoding" || lowerKey === "upgrade" || lowerKey.startsWith("access-control-")) {
+        continue;
+      }
+      res.setHeader(key, value);
+    }
+    applyFetchProxyCors(res);
+    const setCookie = proxyRes.headers["set-cookie"] ?? [];
+    if (setCookie.length > 0) {
+      res.setHeader(
+        "x-sootsim-set-cookie",
+        (Array.isArray(setCookie) ? setCookie : [setCookie]).join(", ")
+      );
+    }
+    res.statusCode = status;
+    await (0, import_promises.pipeline)(proxyRes, res);
+  };
+  try {
+    await proxy(upstreamUrl, originalMethod, body, 0);
+  } catch (err) {
+    if (res.headersSent) {
+      res.destroy(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    const norm = normalizeHostname(upstreamUrl.hostname);
+    if (isLoopbackHost(norm) && err?.code === "ECONNREFUSED") {
+      const altHost = norm === "::1" ? "127.0.0.1" : norm === "127.0.0.1" ? "::1" : "127.0.0.1";
+      if (altHost !== norm) {
+        try {
+          const altUrl = new URL(upstreamUrl.href);
+          altUrl.hostname = altHost;
+          await proxy(altUrl, originalMethod, body, 0);
+          return;
+        } catch {
+        }
+      }
+    }
+    applyFetchProxyCors(res);
+    res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end(`fetch proxy error: ${formatFetchProxyError(upstreamUrl.href, err)}`);
+  }
+}
+async function handleBundleProxyRequest(req, res) {
+  const params = new URLSearchParams((req.url || "").split("?")[1] || "");
+  const target = params.get("url");
+  if (!target) {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("bundle-proxy: missing url query param");
+    return;
+  }
+  let targetUrl;
+  try {
+    targetUrl = new URL(target);
+  } catch {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("bundle-proxy: invalid url");
+    return;
+  }
+  if (!isLoopbackHost(targetUrl.hostname)) {
+    applyFetchProxyCors(res);
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("bundle-proxy: only loopback targets allowed");
+    return;
+  }
+  await handleFetchProxyRequest(req, res);
+}
+function handleAppApiRequest(req, res) {
+  const reqUrl = req.url || "";
+  let targetPath = "";
+  let targetOrigin = "";
+  if (reqUrl.startsWith("/__app-api?")) {
+    const parsed = new URL(reqUrl, "http://sootsim.local");
+    targetPath = parsed.searchParams.get("path") || "";
+    targetOrigin = parsed.searchParams.get("origin")?.trim() || "";
+  } else if (reqUrl.startsWith("/__app-api/")) {
+    targetPath = reqUrl.slice("/__app-api".length);
+  } else {
+    return false;
+  }
+  if (!targetOrigin) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: missing origin query param");
+    return true;
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": req.headers.origin || "*",
+      "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+      "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] || "*",
+      "Access-Control-Allow-Credentials": "true",
+      "Access-Control-Max-Age": "86400"
+    });
+    res.end();
+    return true;
+  }
+  let targetUrl;
+  try {
+    targetUrl = new URL(targetPath, targetOrigin);
+  } catch {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: invalid origin or path");
+    return true;
+  }
+  const transport = targetUrl.protocol === "https:" ? import_https.default : import_http.default;
+  const fwdHeaders = buildAppApiProxyHeaders(req.headers, targetUrl);
+  const proxyReq = transport.request(
+    {
+      hostname: normalizeHostname(targetUrl.hostname),
+      port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
+      path: targetUrl.pathname + targetUrl.search,
+      method: req.method,
+      headers: fwdHeaders,
+      ...loopbackTlsOptions(targetUrl)
+    },
+    (proxyRes) => {
+      const exposedHeaders = Object.keys(proxyRes.headers).filter((name) => {
+        const lower = name.toLowerCase();
+        return !lower.startsWith("access-control-") && lower !== "set-cookie";
+      }).join(", ");
+      res.writeHead(proxyRes.statusCode ?? 502, {
+        ...proxyRes.headers,
+        "access-control-allow-origin": req.headers.origin || "*",
+        "access-control-allow-credentials": "true",
+        "access-control-expose-headers": exposedHeaders
+      });
+      proxyRes.pipe(res);
+    }
+  );
+  proxyReq.on("error", (err) => {
+    res.statusCode = 502;
+    res.end(`app proxy error: ${err.message}`);
+  });
+  req.pipe(proxyReq);
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAppApiProxyHeaders,
+  buildFetchProxyHeaders,
+  handleAppApiRequest,
+  handleBundleProxyRequest,
+  handleFetchProxyRequest,
+  isAppApiRequestUrl,
+  isBundleProxyRequestUrl,
+  isFetchProxyRequestUrl
+});

package/dist-lib/host/fetch-proxy-overrides.cjs

@@ -0,0 +1,63 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/fetch-proxy-overrides.ts
+var fetch_proxy_overrides_exports = {};
+__export(fetch_proxy_overrides_exports, {
+  FETCH_PROXY_BROWSER_USER_AGENT: () => FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders: () => getFetchProxyTargetHeaders
+});
+module.exports = __toCommonJS(fetch_proxy_overrides_exports);
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders
+});

package/dist-lib/host/fetch-proxy-overrides.mjs

@@ -0,0 +1,37 @@
+/*! rnx v0.1.527 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/host/fetch-proxy-overrides.ts
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+export {
+  FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders
+};