@maintainer-pro/ai-bridge 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maintainer-pro/ai-bridge",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Local bridge daemon that pairs a machine to Maintainer Pro and configures multiple client sandboxes.",
   "keywords": [
     "maintainer-pro",

package/src/daemon.mjs

@@ -2343,7 +2343,8 @@ async function handleAiProxyHttpFromAdmin(msg, ws) {
       ? Buffer.from(msg.body, "base64")
       : Buffer.alloc(0),
     headers,
-    ctx.portUrls
+    ctx.portUrls,
+    ctx.publicBase
   );
 
   if (pathname === "/ai-ui.iife.js") {
@@ -2615,6 +2616,7 @@ function handleProxyHttpFromAdmin(msg) {
       chunks: [],
       headers,
       portUrls: ctx.portUrls,
+      publicBase: ctx.publicBase,
     });
     const entry = proxyHttpReqs.get(id);
     if (entry.rewrite) {
@@ -2623,7 +2625,8 @@ function handleProxyHttpFromAdmin(msg) {
         const body = rewriteShareRequestBody(
           Buffer.concat(entry.chunks),
           headers,
-          ctx.portUrls
+          ctx.portUrls,
+          ctx.publicBase
         );
         if (body?.length) req.write(body);
         req.end();
@@ -2651,7 +2654,8 @@ function handleProxyHttpBodyFromAdmin(msg) {
       const body = rewriteShareRequestBody(
         Buffer.concat(entry.chunks || []),
         entry.headers,
-        entry.portUrls
+        entry.portUrls,
+        entry.publicBase
       );
       if (body?.length) req.write(body);
       req.end();

package/src/share-rewrite.mjs

@@ -360,13 +360,17 @@ export function rewriteMappedLocalUrls(text, portUrls) {
  * @param {Record<string, string>} headers
  * @param {Record<string, string> | null | undefined} portUrls
  */
-export function rewriteShareRequestBody(body, headers, portUrls) {
-  if (!body || !portUrls || !Object.keys(portUrls).length) return body;
+export function rewriteShareRequestBody(body, headers, portUrls, publicBase) {
+  if (!body) return body;
   const buf = Buffer.isBuffer(body) ? body : Buffer.from(body);
   if (!buf.length) return buf;
   if (!shouldRewriteBody(headers) && !isProbablyUtf8Text(buf)) return buf;
-  const text = buf.toString("utf8");
-  const next = rewriteMappedLocalUrls(text, portUrls);
+  let text = buf.toString("utf8");
+  let next = text;
+  if (portUrls && Object.keys(portUrls).length) {
+    next = rewriteMappedLocalUrls(next, portUrls);
+  }
+  if (publicBase) next = rewriteShareOriginPaths(next, publicBase);
   if (next === text) return buf;
   return Buffer.from(next, "utf8");
 }
@@ -405,35 +409,106 @@ function rewriteHeaderUrls(headers, publicBase, port, portUrls) {
       publicBase
     );
   }
-  if (!(portUrls && Object.keys(portUrls).length)) return;
-  for (const key of Object.keys(headers)) {
-    const lower = key.toLowerCase();
-    if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
-      continue;
+  if (portUrls && Object.keys(portUrls).length) {
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase();
+      if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
+        continue;
+      }
+      headers[key] = rewriteMappedLocalUrls(headers[key], portUrls);
+    }
+  }
+  if (publicBase) {
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase();
+      if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
+        continue;
+      }
+      headers[key] = rewriteShareOriginPaths(headers[key], publicBase);
+    }
+  }
+}
+
+/**
+ * Apps that honor X-Forwarded-Host emit https://admin-host/oauth2 instead of
+ * localhost:8080/oauth2. Put those back under /p/{token}/{slug} so the token
+ * and app route stay on the URL.
+ *
+ * @param {string} value
+ * @param {string} publicBase
+ */
+export function prefixShareOriginUrl(value, publicBase) {
+  if (!value || !publicBase) return value;
+  try {
+    const base = new URL(String(publicBase).replace(/\/$/, ""));
+    const prefix = base.pathname.replace(/\/$/, "");
+    if (!prefix || prefix.indexOf("/p/") !== 0) return value;
+    const u = new URL(String(value), base);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return value;
+    if (String(u.hostname || "").toLowerCase() !== String(base.hostname || "").toLowerCase()) {
+      return value;
     }
-    headers[key] = rewriteMappedLocalUrls(headers[key], portUrls);
+    const reqPort = u.port || (u.protocol === "https:" ? "443" : "80");
+    const basePort = base.port || (base.protocol === "https:" ? "443" : "80");
+    if (reqPort !== basePort) return value;
+    const path = u.pathname || "/";
+    if (path === prefix || path.indexOf(prefix + "/") === 0) return u.toString();
+    if (path.indexOf("/p/") === 0) return u.toString();
+    u.pathname = path === "/" ? prefix : prefix + path;
+    return u.toString();
+  } catch {
+    return value;
   }
 }
 
+export function rewriteShareOriginPaths(text, publicBase) {
+  if (!text || !publicBase) return text;
+  let origin = "";
+  try {
+    origin = new URL(String(publicBase).replace(/\/$/, "")).origin;
+  } catch {
+    return text;
+  }
+  if (!origin) return text;
+  const originEsc = origin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const originSlashEsc = origin
+    .replace(/\//g, "\\/")
+    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let out = String(text);
+  out = out.replace(new RegExp(originEsc + "(?:/[^\\s'\"<>\\\\]*)?", "gi"), function (matched) {
+    return prefixShareOriginUrl(matched, publicBase);
+  });
+  out = out.replace(
+    new RegExp(originSlashEsc + "(?:\\\\/[^\\s'\"<>]*)?", "gi"),
+    function (matched) {
+      const unescaped = matched.replace(/\\\//g, "/");
+      return prefixShareOriginUrl(unescaped, publicBase).replace(/\//g, "\\/");
+    }
+  );
+  return out;
+}
+
 function rewriteLocation(value, publicBase, port, portUrls) {
   if (!publicBase && !(portUrls && Object.keys(portUrls).length)) return value;
   try {
     const u = new URL(value, `http://127.0.0.1:${Number(port) || 0}`);
-    if (!isLoopbackHost(u.hostname)) {
-      return rewriteMappedLocalUrls(String(value), portUrls);
-    }
-    const locPort = Number(u.port) || Number(port) || 0;
-    const mapped =
-      mappedUrlForPort(portUrls, locPort) ||
-      String(publicBase || "").replace(/\/$/, "");
-    if (!mapped) return value;
-    const prefix = proxyPathPrefix(mapped);
-    let path = u.pathname || "/";
-    if (prefix && (path === prefix || path.startsWith(`${prefix}/`))) {
-      path = path.slice(prefix.length) || "/";
+    if (isLoopbackHost(u.hostname)) {
+      const locPort = Number(u.port) || Number(port) || 0;
+      const mapped =
+        mappedUrlForPort(portUrls, locPort) ||
+        String(publicBase || "").replace(/\/$/, "");
+      if (!mapped) return value;
+      const prefix = proxyPathPrefix(mapped);
+      let path = u.pathname || "/";
+      if (prefix && (path === prefix || path.startsWith(`${prefix}/`))) {
+        path = path.slice(prefix.length) || "/";
+      }
+      if (path === "/") return `${mapped}${u.search}${u.hash}`;
+      return `${mapped}${path}${u.search}${u.hash}`;
     }
-    if (path === "/") return `${mapped}${u.search}${u.hash}`;
-    return `${mapped}${path}${u.search}${u.hash}`;
+    const fromPorts = rewriteMappedLocalUrls(String(value), portUrls);
+    if (fromPorts !== String(value)) return fromPorts;
+    if (publicBase) return prefixShareOriginUrl(String(value), publicBase);
   } catch {
     /* keep */
   }
@@ -911,6 +986,7 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
       if (path === p || path.indexOf(p + "/") === 0) return collapse(path);
       var root = p.slice(0, p.lastIndexOf("/"));
       if (root && (path === root || path.indexOf(root + "/") === 0)) return path;
+      if (path.indexOf("/p/") === 0) return path;
       if (path === "/api/v1" || path.indexOf("/api/v1/") === 0) return path;
       return collapse(p + path);
     }
@@ -954,25 +1030,7 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
     return v;
   }
   function addNet(v) {
-    if (typeof v !== "string" || !v) return v;
-    var mapped = mapLocal(v);
-    if (mapped !== v) return mapped;
-    try {
-      if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(v) || v.indexOf("//") === 0) {
-        var net = new URL(v, location.href);
-        if (net.origin !== location.origin) return v;
-        if (net.pathname === p || net.pathname.indexOf(p + "/") === 0) return v;
-        if (!isAsset(net.pathname)) return v;
-        net.pathname = prefixPath(net.pathname);
-        return net.toString();
-      }
-    } catch (e) {}
-    if (v.charAt(0) === "/" && v.charAt(1) !== "/") {
-      if (v === p || v.indexOf(p + "/") === 0) return collapse(v);
-      if (!isAsset(v)) return v;
-      return prefixPath(v);
-    }
-    return v;
+    return addNav(v);
   }
   function mapSel(sel) {
     if (typeof sel !== "string") return sel;
@@ -1156,17 +1214,47 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
       return text;
     }
   }
-  function mapUrl(v) {
+  function appPrefixFromHref(href) {
+    try {
+      var u = new URL(String(href || ""));
+      var parts = u.pathname.split("/").filter(Boolean);
+      if (parts[0] === "p" && parts[1] && parts[2]) {
+        return "/" + parts[0] + "/" + parts[1] + "/" + parts[2];
+      }
+    } catch (e) {}
+    return "";
+  }
+  function prefixWith(url, prefix) {
+    if (!prefix) return url;
+    try {
+      var u = new URL(url, self.location.href);
+      if (u.origin !== self.location.origin) return url;
+      if (u.pathname.indexOf("/p/") === 0) return url;
+      if (u.pathname === prefix || u.pathname.indexOf(prefix + "/") === 0) return url;
+      u.pathname = u.pathname === "/" ? prefix : prefix + u.pathname;
+      return u.toString();
+    } catch (e) {}
+    return url;
+  }
+  function mapUrl(v, prefix) {
     if (typeof v !== "string" || !v) return v;
     if (v.indexOf("/__mp/") !== -1) return v;
-    return rewriteText(v);
+    return prefixWith(rewriteText(v), prefix);
   }
   self.addEventListener("fetch", function (event) {
     var req = event.request;
     if (req.url.indexOf("/__mp/") !== -1) return;
     event.respondWith(
       (async function () {
-        var url = mapUrl(req.url);
+        var client = null;
+        try {
+          if (event.clientId) client = await self.clients.get(event.clientId);
+        } catch (e) {}
+        var prefix =
+          appPrefixFromHref(client && client.url) ||
+          appPrefixFromHref(req.referrer) ||
+          appPrefixFromHref(self.registration && self.registration.scope);
+        var url = mapUrl(req.url, prefix);
         var method = req.method;
         var headers = new Headers(req.headers);
         var body;
@@ -1195,15 +1283,24 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
           } catch (e) {}
         }
         var res = await fetch(new Request(url, init));
+        var outHeaders = new Headers(res.headers);
+        var loc = outHeaders.get("location");
+        if (loc) outHeaders.set("location", mapUrl(loc, prefix));
         var resType = res.headers.get("content-type") || "";
         if (
           !/html|javascript|ecmascript|json|css|xml|svg|text|urlencoded/.test(resType)
         ) {
+          if (loc && outHeaders.get("location") !== loc) {
+            return new Response(res.body, {
+              status: res.status,
+              statusText: res.statusText,
+              headers: outHeaders,
+            });
+          }
           return res;
         }
         var resText = await res.text();
         var mapped = rewriteText(resText);
-        var outHeaders = new Headers(res.headers);
         outHeaders.delete("content-length");
         outHeaders.delete("content-encoding");
         return new Response(mapped, {
@@ -1305,6 +1402,13 @@ export function processShareHttpResponse(opts) {
       mutated = true;
     }
   }
+  if (publicBase && rewriteTextBody) {
+    const prefixed = rewriteShareOriginPaths(text, publicBase);
+    if (prefixed !== text) {
+      text = prefixed;
+      mutated = true;
+    }
+  }
   if (aiPublicBase) {
     const withShareUrls = rewriteLocalSidecarUrls(text, aiPublicBase, publicBase);
     if (withShareUrls !== text) {