@maintainer-pro/ai-bridge 0.1.22 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maintainer-pro/ai-bridge",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Local bridge daemon that pairs a machine to Maintainer Pro and configures multiple client sandboxes.",
   "keywords": [
     "maintainer-pro",
@@ -28,7 +28,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@maintainer-pro/ai-cli": "^0.1.12",
+    "@maintainer-pro/ai-cli": "^0.1.13",
     "@maintainer-pro/ai-server": "^0.1.7"
   }
 }

package/src/daemon.mjs

@@ -16,6 +16,7 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 import { createLogger, ensureProjectDataDir } from "@maintainer-pro/ai-cli";
 import { findIife, startAiServer } from "@maintainer-pro/ai-server";
 import {
@@ -39,7 +40,9 @@ import {
 } from "./discarded-tunnels.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const requireFromHere = createRequire(import.meta.url);
 const PACKAGE_VERSION = readPackageVersion();
+const PACKAGE_VERSIONS = readPackageVersions();
 const HEARTBEAT_MS = 15_000;
 const WS_PING_MS = 10_000;
 const WS_RECONNECT_MIN_MS = 1_000;
@@ -157,6 +160,53 @@ function readPackageVersion() {
   }
 }
 
+function readDepPackageVersion(name) {
+  const files = [];
+  try {
+    files.push(requireFromHere.resolve(`${name}/package.json`));
+  } catch {
+    /* try nested next */
+  }
+  try {
+    const serverDir = path.dirname(
+      requireFromHere.resolve("@maintainer-pro/ai-server/package.json")
+    );
+    files.push(path.join(serverDir, "node_modules", name, "package.json"));
+    files.push(path.join(serverDir, "..", name.replace("@maintainer-pro/", ""), "package.json"));
+  } catch {
+    /* ignore */
+  }
+  for (const file of files) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (typeof pkg.version === "string" && pkg.version) return pkg.version;
+    } catch {
+      /* try next */
+    }
+  }
+  return null;
+}
+
+function readPackageVersions() {
+  return {
+    bridge: PACKAGE_VERSION,
+    cli: readDepPackageVersion("@maintainer-pro/ai-cli"),
+    server: readDepPackageVersion("@maintainer-pro/ai-server"),
+    ui: readDepPackageVersion("@maintainer-pro/ai-ui"),
+  };
+}
+
+function formatPackageVersions(versions = PACKAGE_VERSIONS) {
+  return [
+    versions.bridge && `bridge ${versions.bridge}`,
+    versions.cli && `cli ${versions.cli}`,
+    versions.server && `server ${versions.server}`,
+    versions.ui && `ui ${versions.ui}`,
+  ]
+    .filter(Boolean)
+    .join(" · ");
+}
+
 async function warnIfBridgeOutdated() {
   const fromWorkspace = path
     .normalize(__dirname)
@@ -2259,6 +2309,7 @@ function shareProxyContext(msg, ws, appId) {
     acceptEncoding,
     port: localPortForProxy(ws, appId),
     portUrls: { ...fromWs, ...fromMsg },
+    bypassCors: msg?.bypassCors === true,
   };
 }
 
@@ -2292,9 +2343,13 @@ function replyShareInterceptor(id, ctx, path) {
   let body = "";
   if (pathname === "/__mp/sw.js") {
     headers["service-worker-allowed"] = tokenRoot;
-    body = shareServiceWorkerScript(ctx.portUrls, tokenRoot);
+    body = shareServiceWorkerScript(ctx.portUrls, tokenRoot, ctx.bypassCors);
   } else {
-    body = shareShimScript(publicPathPrefix(ctx.publicBase), ctx.portUrls);
+    body = shareShimScript(
+      publicPathPrefix(ctx.publicBase),
+      ctx.portUrls,
+      ctx.bypassCors
+    );
   }
   replyProxyHttp(id, 200, headers, body);
   return true;
@@ -2325,6 +2380,7 @@ function bridgeEmbedConfigJs(ws) {
     logLevel: "debug",
     maintainerProUrl: bridgeCfg?.adminUrl || "",
     maintainerProApiKey: String(store.clientKey || "").trim(),
+    versions: PACKAGE_VERSIONS,
   };
   return `window.__MAINTAINER_PRO__=${JSON.stringify(payload)};`;
 }
@@ -2425,6 +2481,234 @@ async function handleAiProxyHttpFromAdmin(msg, ws) {
   });
 }
 
+const EXTERNAL_PROXY_TIMEOUT_MS = 10 * 60 * 1000;
+const EXTERNAL_PROXY_MAX_REDIRECTS = 5;
+const EXTERNAL_PROXY_DROP_HEADERS = new Set([
+  "cookie",
+  "set-cookie",
+  "host",
+  "origin",
+  "referer",
+  "referrer",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "content-length",
+  "te",
+  "trailer",
+  "x-mp-target",
+  "x-forwarded-proto",
+  "x-forwarded-host",
+  "x-forwarded-for",
+]);
+
+function parseExternalProxyUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(String(value || ""));
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  const parts = parsed.pathname.split("/").filter(Boolean);
+  if (parts[0] === "p" && parts[2] === "__cors") return null;
+  return parsed;
+}
+
+function externalProxyHeaders(incoming, targetHost) {
+  /** @type {Record<string, string>} */
+  const headers = {};
+  if (incoming && typeof incoming === "object") {
+    for (const [key, value] of Object.entries(incoming)) {
+      const lower = String(key).toLowerCase();
+      if (EXTERNAL_PROXY_DROP_HEADERS.has(lower)) continue;
+      if (lower.startsWith("sec-fetch-")) continue;
+      if (typeof value === "string" && value) headers[key] = value;
+    }
+  }
+  headers.host = targetHost;
+  return headers;
+}
+
+function failExternalProxyHttp(id, error) {
+  proxyHttpReqs.delete(id);
+  bridgeSend({
+    type: "proxy.http.error",
+    id,
+    error: error instanceof Error ? error.message : String(error || "Upstream error"),
+  });
+}
+
+function streamExternalProxyHttp(id, res) {
+  const stream = randomBytes(8).toString("hex");
+  /** @type {Record<string, string>} */
+  const outHeaders = {};
+  for (const [key, value] of Object.entries(res.headers || {})) {
+    if (value == null) continue;
+    const lower = String(key).toLowerCase();
+    if (lower === "set-cookie" || lower === "cookie") continue;
+    outHeaders[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  bridgeSend({
+    type: "proxy.http.start",
+    id,
+    stream,
+    status: res.statusCode || 502,
+    headers: outHeaders,
+  });
+  res.on("data", (chunk) => {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    for (let offset = 0; offset < buf.length; offset += PROXY_CHUNK_BYTES) {
+      const end = Math.min(offset + PROXY_CHUNK_BYTES, buf.length);
+      bridgeSend({
+        type: "proxy.http.chunk",
+        id,
+        stream,
+        data: Buffer.from(buf.subarray(offset, end)).toString("base64"),
+        eof: false,
+      });
+    }
+  });
+  res.on("end", () => {
+    proxyHttpReqs.delete(id);
+    bridgeSend({
+      type: "proxy.http.chunk",
+      id,
+      stream,
+      data: "",
+      eof: true,
+    });
+  });
+  res.on("error", (err) => {
+    failExternalProxyHttp(id, err);
+  });
+}
+
+function fetchExternalProxyUrl(entry, url, method, headers, body, redirectsLeft) {
+  const parsed = parseExternalProxyUrl(url);
+  if (!parsed) {
+    failExternalProxyHttp(entry.id, "Invalid external URL");
+    return;
+  }
+  const lib = parsed.protocol === "https:" ? https : http;
+  /** @type {Record<string, string>} */
+  const reqHeaders = { ...headers, host: parsed.host };
+  const sendBody =
+    body?.length && method !== "GET" && method !== "HEAD" ? body : null;
+  if (sendBody) reqHeaders["content-length"] = String(sendBody.length);
+  else delete reqHeaders["content-length"];
+
+  let req;
+  try {
+    req = lib.request(
+      {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parsed.port || undefined,
+        path: `${parsed.pathname}${parsed.search}`,
+        method,
+        headers: reqHeaders,
+      },
+      (res) => {
+        const status = res.statusCode || 502;
+        const loc = res.headers.location;
+        if (
+          loc &&
+          status >= 300 &&
+          status < 400 &&
+          redirectsLeft > 0
+        ) {
+          res.resume();
+          let next;
+          try {
+            next = new URL(loc, parsed).href;
+          } catch {
+            failExternalProxyHttp(entry.id, "Invalid redirect");
+            return;
+          }
+          const preserve = status === 307 || status === 308;
+          const nextMethod = preserve
+            ? method
+            : method === "HEAD"
+              ? "HEAD"
+              : "GET";
+          const nextBody =
+            preserve && nextMethod !== "GET" && nextMethod !== "HEAD"
+              ? body
+              : Buffer.alloc(0);
+          fetchExternalProxyUrl(
+            entry,
+            next,
+            nextMethod,
+            headers,
+            nextBody,
+            redirectsLeft - 1
+          );
+          return;
+        }
+        streamExternalProxyHttp(entry.id, res);
+      }
+    );
+  } catch (err) {
+    failExternalProxyHttp(entry.id, err);
+    return;
+  }
+  req.setTimeout(EXTERNAL_PROXY_TIMEOUT_MS, () => {
+    req.destroy(new Error("Upstream timeout"));
+  });
+  req.on("error", (err) => {
+    failExternalProxyHttp(entry.id, err);
+  });
+  entry.req = req;
+  if (sendBody) req.write(sendBody);
+  req.end();
+}
+
+function startExternalProxyHttp(entry) {
+  const body = Buffer.concat(entry.chunks || []);
+  fetchExternalProxyUrl(
+    entry,
+    entry.url,
+    entry.method,
+    entry.headers,
+    body,
+    EXTERNAL_PROXY_MAX_REDIRECTS
+  );
+}
+
+function handleExternalProxyHttpFromAdmin(msg) {
+  const id = typeof msg.id === "string" ? msg.id : "";
+  const parsed = parseExternalProxyUrl(msg.externalUrl);
+  if (!id) return;
+  if (!parsed) {
+    failExternalProxyHttp(id, "Invalid external URL");
+    return;
+  }
+  const existing = proxyHttpReqs.get(id);
+  if (existing) {
+    destroyProxyHttpReq(existing);
+    proxyHttpReqs.delete(id);
+  }
+  const method = String(msg.method || "GET").toUpperCase();
+  const initialBody =
+    typeof msg.body === "string" && msg.body
+      ? Buffer.from(msg.body, "base64")
+      : null;
+  const entry = {
+    req: null,
+    external: true,
+    id,
+    url: parsed.href,
+    method,
+    headers: externalProxyHeaders(msg.headers, parsed.host),
+    chunks: [],
+  };
+  proxyHttpReqs.set(id, entry);
+  if (initialBody?.length) entry.chunks.push(initialBody);
+  if (msg.bodyEof !== false) startExternalProxyHttp(entry);
+}
+
 function handleProxyHttpFromAdmin(msg) {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sandboxId = typeof msg.sandboxId === "string" ? msg.sandboxId : "";
@@ -2439,6 +2723,10 @@ function handleProxyHttpFromAdmin(msg) {
     });
     return;
   }
+  if (typeof msg.externalUrl === "string" && msg.externalUrl.trim()) {
+    handleExternalProxyHttpFromAdmin(msg);
+    return;
+  }
   if (isAiServerAppId(appId, ws)) {
     void handleAiProxyHttpFromAdmin(msg, ws);
     return;
@@ -2651,11 +2939,16 @@ function handleProxyHttpBodyFromAdmin(msg) {
   const id = typeof msg.id === "string" ? msg.id : "";
   const entry = proxyHttpReqs.get(id);
   if (!entry) return;
-  const req = entry.req || entry;
   const chunk =
     typeof msg.data === "string" && msg.data
       ? Buffer.from(msg.data, "base64")
       : null;
+  if (entry.external) {
+    if (chunk?.length) entry.chunks.push(chunk);
+    if (msg.eof === true) startExternalProxyHttp(entry);
+    return;
+  }
+  const req = entry.req || entry;
   if (entry.rewrite) {
     if (chunk?.length) entry.chunks.push(chunk);
     if (msg.eof === true) {
@@ -4834,6 +5127,7 @@ async function sendHeartbeat(cfg, folders, localStates) {
     hostname: os.hostname(),
     platform: `${os.platform()}-${os.arch()}`,
     bridgeVersion: PACKAGE_VERSION,
+    packageVersions: PACKAGE_VERSIONS,
     folders,
     issues: await buildIssues(cfg, localStates),
     workspaces: localStates.map((st) => ({
@@ -4866,6 +5160,7 @@ function buildLightHeartbeatPayload(cfg, folders) {
     hostname: os.hostname(),
     platform: `${os.platform()}-${os.arch()}`,
     bridgeVersion: PACKAGE_VERSION,
+    packageVersions: PACKAGE_VERSIONS,
     folders,
   };
 }
@@ -4887,6 +5182,7 @@ async function buildHeartbeatPayload(cfg, folders, localStates) {
     hostname: os.hostname(),
     platform: `${os.platform()}-${os.arch()}`,
     bridgeVersion: PACKAGE_VERSION,
+    packageVersions: PACKAGE_VERSIONS,
     folders,
     issues: await buildIssues(cfg, localStates),
     workspaces: localStates.map((st) => ({
@@ -5021,6 +5317,7 @@ async function pairFlow(args) {
     hostname: os.hostname(),
     platform: `${os.platform()}-${os.arch()}`,
     bridgeVersion: PACKAGE_VERSION,
+    packageVersions: PACKAGE_VERSIONS,
     name: os.hostname(),
   });
 
@@ -5048,9 +5345,9 @@ async function main() {
     process.exit(0);
   }
 
-  logger.debug(
-    { logLevel: logger.level, nodeEnv: process.env.NODE_ENV },
-    "bridge starting"
+  logger.info(
+    { versions: PACKAGE_VERSIONS },
+    `bridge v${PACKAGE_VERSION} starting (${formatPackageVersions()})`
   );
   void warnIfBridgeOutdated();
 

package/src/share-rewrite.mjs

@@ -155,11 +155,33 @@ function isImmutableAssetPath(path) {
   return (
     /\/_next\/static\//.test(p) ||
     /\/__nextjs_font\//.test(p) ||
-    /\/node_modules\/\.vite\//.test(p) ||
     /\.[0-9a-f]{8,}\.(?:js|css|woff2?)$/i.test(p)
   );
 }
 
+function isViteDevSourcePath(path) {
+  const raw = String(path || "");
+  const p = raw.split("?")[0] || "";
+  if (/[?&]t=\d+/.test(raw)) return true;
+  if (/\/(?:@vite(?:\/|$)|@react-refresh|@fs\/|@id\/)/.test(p)) return true;
+  if (/\/node_modules\/\.vite\//.test(p)) return true;
+  if (/\/src\//.test(p)) return true;
+  if (
+    /\.(?:m?[jt]sx?|vue|svelte|css|scss|sass|less)$/i.test(p) &&
+    !/\/node_modules\//.test(p)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function isDocumentPath(path) {
+  const p = String(path || "").split("?")[0] || "";
+  if (!p || p === "/") return true;
+  if (/\.html?$/i.test(p)) return true;
+  return !/\.[A-Za-z0-9]+$/.test(p);
+}
+
 function isNoStorePath(path) {
   const p = String(path || "").split("?")[0] || "";
   return (
@@ -169,11 +191,9 @@ function isNoStorePath(path) {
     /\/_next\/webpack-hmr/i.test(p) ||
     /\/_next\/webpack\/hmr/i.test(p) ||
     /\/__nextjs_original-stack-frames/i.test(p) ||
-    /\/@vite(?:\/|$)/.test(p) ||
-    /\/@react-refresh/.test(p) ||
-    /\/@fs\//.test(p) ||
-    /\/@id\//.test(p) ||
-    /\/__mp\//.test(p)
+    /\/__mp\//.test(p) ||
+    isViteDevSourcePath(path) ||
+    isDocumentPath(path)
   );
 }
 
@@ -396,12 +416,12 @@ export function shareTokenRoot(publicBase) {
   return prefix.endsWith("/") ? prefix : `${prefix}/`;
 }
 
-export function shareShimScript(pathPrefix, portUrls) {
-  return `(${shareProxyShim.toString()})(${JSON.stringify(pathPrefix || "")},${JSON.stringify(portUrls || {})},${rewriteMappedLocalUrls.toString()});`;
+export function shareShimScript(pathPrefix, portUrls, bypassCors) {
+  return `(${shareProxyShim.toString()})(${JSON.stringify(pathPrefix || "")},${JSON.stringify(portUrls || {})},${rewriteMappedLocalUrls.toString()},${JSON.stringify(Boolean(bypassCors))});`;
 }
 
-export function shareServiceWorkerScript(portUrls, tokenRoot) {
-  return `(${shareServiceWorkerMain.toString()})(${JSON.stringify(portUrls || {})},${JSON.stringify(tokenRoot || "/")},${rewriteMappedLocalUrls.toString()});`;
+export function shareServiceWorkerScript(portUrls, tokenRoot, bypassCors) {
+  return `(${shareServiceWorkerMain.toString()})(${JSON.stringify(portUrls || {})},${JSON.stringify(tokenRoot || "/")},${rewriteMappedLocalUrls.toString()},${JSON.stringify(Boolean(bypassCors))});`;
 }
 
 function rewriteHeaderUrls(headers, publicBase, port, portUrls) {
@@ -596,7 +616,7 @@ function gzipIfRequested(payload, headers, acceptEncoding) {
 
 function rewriteCacheKey(publicBase, path) {
   if (!isImmutableAssetPath(path) && !isLongCacheScriptPath(path)) return null;
-  return `${publicBase || ""}\0${String(path || "").split("?")[0]}`;
+  return `${publicBase || ""}\0${String(path || "")}`;
 }
 
 function rememberRewrite(key, payload, status, headers, etag) {
@@ -698,6 +718,19 @@ function isShareAssetPath(path) {
   );
 }
 
+function rewriteShareAsLocalEnv(body) {
+  let out = String(body);
+  out = out.replace(
+    /(\/\.\*localhost\.\*\/\.test\()([^)]+)(\))/g,
+    "($1$2$3||location.pathname.indexOf(\"/p/\")===0)"
+  );
+  out = out.replace(
+    /((?:window\.)?location\.hostname)\s*===\s*(['"])localhost\2/g,
+    "($1===$2localhost$2||location.pathname.indexOf(\"/p/\")===0)"
+  );
+  return out;
+}
+
 function prefixQuotedAssetPaths(body, pathPrefix) {
   if (!pathPrefix) return body;
   return String(body).replace(/(["'`])(\/(?!\/)[^"'`]*)/g, (full, q, path) => {
@@ -844,6 +877,7 @@ function prefixRootPaths(body, publicBase, contentType = "") {
   const css = mime === "text/css" || (!isCode && !html && /css/.test(mime));
   if (!html && !css) {
     let code = rewriteViteBaseLiterals(body, pathPrefix);
+    code = rewriteShareAsLocalEnv(code);
     code = prefixQuotedAssetPaths(code, pathPrefix);
     code = code.replace(
       /(?<![A-Za-z0-9])\/__nextjs_/g,
@@ -913,7 +947,7 @@ function isHtmlDocument(headers, body) {
 
 function isScriptRequestPath(path) {
   const p = String(path || "").split("?")[0]?.toLowerCase() || "";
-  return /\.(?:m?js|cjs)$/.test(p);
+  return /\.(?:m?[jt]sx?|cjs)$/.test(p);
 }
 
 function isScriptOrJsonBody(headers, path) {
@@ -989,10 +1023,11 @@ function injectMaintainerProEmbed(html, aiPublicBase) {
 /**
  * Intercept every browser request and map listed app ports onto share URLs.
  */
-function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
+function shareProxyShim(p, portMap, rewriteMappedLocalUrls, bypassCors) {
   if (!p || window.__MP_SHARE_SHIM__) return;
   window.__MP_SHARE_SHIM__ = 1;
   window.__MP_PORT_MAP__ = portMap || {};
+  window.__MP_BYPASS_CORS__ = Boolean(bypassCors);
   function rewriteText(text) {
     if (typeof text !== "string" || !text || typeof rewriteMappedLocalUrls !== "function") {
       return text;
@@ -1094,46 +1129,67 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
     } catch (e) {}
     return v;
   }
+  function isCorsProxyPath(pathname) {
+    var parts = String(pathname || "").split("/").filter(Boolean);
+    return parts[0] === "p" && parts[2] === "__cors";
+  }
+  function shareToken() {
+    try {
+      var parts = location.pathname.split("/").filter(Boolean);
+      if (parts[0] === "p" && parts[1]) return parts[1];
+    } catch (e) {}
+    return "";
+  }
+  function corsProxy(v) {
+    if (!bypassCors || typeof v !== "string" || !v) return v;
+    if (!/^(https?:)\/\//i.test(v)) return v;
+    try {
+      var u = new URL(v);
+      if (u.protocol !== "http:" && u.protocol !== "https:") return v;
+      if (loopback(u.hostname)) return v;
+      if (u.origin === location.origin) return v;
+      if (isCorsProxyPath(u.pathname)) return v;
+      var token = shareToken();
+      if (!token) return v;
+      return (
+        location.origin +
+        "/p/" +
+        token +
+        "/__cors?__mp_url=" +
+        encodeURIComponent(u.href)
+      );
+    } catch (e) {}
+    return v;
+  }
   function addNet(v) {
     if (typeof v !== "string" || !v) return v;
     var mapped = mapLocal(v);
     if (mapped !== v) return mapped;
-    var backend = backendBase();
-    var path = "";
-    var search = "";
-    var hash = "";
-    var abs = null;
-    try {
-      if (/^(https?:|wss?:)\/\//i.test(v)) {
-        abs = new URL(v);
-        var host = String(abs.hostname || "")
-          .replace(/^\[|\]$/g, "")
-          .toLowerCase();
-        if (!loopback(host) && host !== String(location.hostname || "").toLowerCase()) {
-          return v;
+    if (/^(https?:|wss?:)\/\//i.test(v)) {
+      try {
+        var abs = new URL(v);
+        if (!loopback(abs.hostname)) {
+          if (/^wss?:/i.test(abs.protocol)) return v;
+          return corsProxy(v);
         }
-        path = abs.pathname || "/";
-        search = abs.search || "";
-        hash = abs.hash || "";
-      } else if (v.charAt(0) === "/" && v.charAt(1) !== "/") {
-        var rel = new URL(v, location.href);
-        path = rel.pathname || "/";
-        search = rel.search || "";
-        hash = rel.hash || "";
-      } else {
-        return addNav(v);
-      }
-    } catch (e) {
-      return addNav(v);
+      } catch (e) {}
     }
-    if (path === "/api/v1" || path.indexOf("/api/v1/") === 0) return v;
-    if (path.indexOf("/p/") === 0) return v;
-    if (path === "/" || path === "") return addNav(v);
-    if (isAsset(path)) return addNav(v);
-    if (backend) {
-      var dest = backend + path + search + hash;
-      if (abs && /^ws/i.test(abs.protocol)) dest = dest.replace(/^http/i, "ws");
-      return dest;
+    if (v.charAt(0) === "/" && v.charAt(1) !== "/") {
+      var backend = backendBase();
+      var path = v.split("?")[0];
+      if (path === "/api/v1" || path.indexOf("/api/v1/") === 0 || path.indexOf("/p/") === 0) {
+        return v;
+      }
+      if (
+        backend &&
+        !isAsset(path) &&
+        (/^\/sreo(?:\/|$)/i.test(path) || /^\/api(?:\/|$)/i.test(path))
+      ) {
+        try {
+          var rel = new URL(v, location.href);
+          return backend + rel.pathname + rel.search + rel.hash;
+        } catch (e) {}
+      }
     }
     return addNav(v);
   }
@@ -1299,17 +1355,27 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
   try {
     var tokenRoot = p.replace(/\/[^/]+$/, "/");
     if (navigator.serviceWorker && tokenRoot.indexOf("/p/") === 0) {
-      navigator.serviceWorker.register(p + "/__mp/sw.js", { scope: tokenRoot });
+      navigator.serviceWorker.register(p + "/__mp/sw.js", {
+        scope: tokenRoot,
+        updateViaCache: "none",
+      });
     }
   } catch (e) {}
 }
 
-function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
+function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls, bypassCors) {
   self.addEventListener("install", function (event) {
     event.waitUntil(self.skipWaiting());
   });
   self.addEventListener("activate", function (event) {
-    event.waitUntil(self.clients.claim());
+    event.waitUntil(
+      self.clients.claim().then(function () {
+        if (!self.caches) return;
+        return self.caches.keys().then(function (keys) {
+          return Promise.all(keys.map(function (key) { return self.caches.delete(key); }));
+        });
+      })
+    );
   });
   function rewriteText(text) {
     if (typeof text !== "string" || !text) return text;
@@ -1352,37 +1418,62 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
     }
     return "";
   }
+  function isCorsProxyPath(pathname) {
+    var parts = String(pathname || "").split("/").filter(Boolean);
+    return parts[0] === "p" && parts[2] === "__cors";
+  }
+  function shareToken() {
+    try {
+      var parts = String(self.registration && self.registration.scope || self.location.pathname)
+        .split("/")
+        .filter(Boolean);
+      if (parts[0] === "p" && parts[1]) return parts[1];
+    } catch (e) {}
+    return "";
+  }
+  function corsProxy(v) {
+    if (!bypassCors || typeof v !== "string" || !v) return v;
+    if (!/^(https?:)\/\//i.test(v)) return v;
+    try {
+      var u = new URL(v, self.location.href);
+      if (u.protocol !== "http:" && u.protocol !== "https:") return v;
+      if (loopback(u.hostname)) return v;
+      if (u.origin === self.location.origin) return v;
+      if (isCorsProxyPath(u.pathname)) return v;
+      var token = shareToken();
+      if (!token) return v;
+      return (
+        self.location.origin +
+        "/p/" +
+        token +
+        "/__cors?__mp_url=" +
+        encodeURIComponent(u.href)
+      );
+    } catch (e) {}
+    return v;
+  }
   function prefixWith(url, prefix) {
-    if (!prefix) return url;
+    if (!prefix) return corsProxy(url);
     try {
-      var backend = backendBase();
-      var parsed = new URL(url, self.location.href);
-      var host = String(parsed.hostname || "")
-        .replace(/^\[|\]$/g, "")
-        .toLowerCase();
-      var pageHost = String(self.location.hostname || "")
-        .replace(/^\[|\]$/g, "")
-        .toLowerCase();
-      if (/^(https?:|wss?:)\/\//i.test(url) && !loopback(host) && host !== pageHost) {
-        return url;
+      if (/^(https?:|wss?:)\/\//i.test(url)) {
+        var abs = new URL(url);
+        if (!loopback(abs.hostname)) {
+          if (/^wss?:/i.test(abs.protocol)) return url;
+          return corsProxy(url);
+        }
       }
-      var path = parsed.pathname || "/";
+      var u = new URL(url, self.location.href);
+      var path = u.pathname || "/";
+      var backend = backendBase();
       if (path === "/api/v1" || path.indexOf("/api/v1/") === 0) return url;
       if (path.indexOf("/p/") === 0) return url;
       if (
         backend &&
-        path !== "/" &&
-        path !== "" &&
-        !/\/(?:_next\/|__nextjs_|@vite(?:\/|$)|@react-refresh(?:\/|$)|@fs\/|@id\/|node_modules\/)/.test(
-          path
-        ) &&
-        !/\.(?:m?[jt]sx?|cjs|mjs|css|scss|sass|less|map|wasm|vue|svelte)$/i.test(path)
+        !/^(https?:|wss?:)\/\//i.test(url) &&
+        (/^\/sreo(?:\/|$)/i.test(path) || /^\/api(?:\/|$)/i.test(path))
       ) {
-        var dest = backend + path + (parsed.search || "") + (parsed.hash || "");
-        if (/^ws/i.test(parsed.protocol)) dest = dest.replace(/^http/i, "ws");
-        return dest;
+        return backend + path + (u.search || "") + (u.hash || "");
       }
-      var u = parsed;
       if (u.origin !== self.location.origin) return url;
       if (u.pathname === "/" || u.pathname === "") return url;
       if (u.pathname === prefix || u.pathname.indexOf(prefix + "/") === 0) return url;
@@ -1394,11 +1485,13 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
   function mapUrl(v, prefix) {
     if (typeof v !== "string" || !v) return v;
     if (v.indexOf("/__mp/") !== -1) return v;
+    if (v.indexOf("/__cors") !== -1) return v;
     return prefixWith(rewriteText(v), prefix);
   }
   self.addEventListener("fetch", function (event) {
     var req = event.request;
     if (req.url.indexOf("/__mp/") !== -1) return;
+    if (req.url.indexOf("/__cors") !== -1) return;
     event.respondWith(
       (async function () {
         var client = null;
@@ -1429,6 +1522,7 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
           credentials: req.credentials,
           redirect: req.redirect,
           referrer: req.referrer,
+          cache: "no-store",
         };
         if (req.mode && req.mode !== "navigate") init.mode = req.mode;
         if (body !== undefined) init.body = body;
@@ -1550,14 +1644,14 @@ export function processShareHttpResponse(opts) {
     text = prefixRootPaths(text, publicBase, headers["content-type"] || "");
     mutated = true;
   }
-  if (Object.keys(portUrls).length && rewriteTextBody) {
+  if (Object.keys(portUrls).length && rewriteTextBody && !isScriptOrJsonBody(headers, path)) {
     const mapped = rewriteMappedLocalUrls(text, portUrls);
     if (mapped !== text) {
       text = mapped;
       mutated = true;
     }
   }
-  if (publicBase && rewriteTextBody) {
+  if (publicBase && rewriteTextBody && !isScriptOrJsonBody(headers, path)) {
     const prefixed = rewriteShareOriginPaths(text, publicBase, portUrls);
     if (prefixed !== text) {
       text = prefixed;