@maintainer-pro/ai-bridge 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maintainer-pro/ai-bridge",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "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.11",
+    "@maintainer-pro/ai-cli": "^0.1.12",
     "@maintainer-pro/ai-server": "^0.1.7"
   }
 }

package/src/daemon.mjs

@@ -257,7 +257,21 @@ function loadConfig() {
   const file = configPath();
   if (!fs.existsSync(file)) return null;
   try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
+    const cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+    let dirty = false;
+    for (const ws of cfg.workspaces || []) {
+      const before = JSON.stringify(ws.hostApps || []);
+      const beforeProxy = JSON.stringify(ws.proxy || null);
+      stripAiServerFromWorkspace(ws);
+      if (
+        JSON.stringify(ws.hostApps || []) !== before ||
+        JSON.stringify(ws.proxy || null) !== beforeProxy
+      ) {
+        dirty = true;
+      }
+    }
+    if (dirty) saveConfig(cfg);
+    return cfg;
   } catch {
     return null;
   }
@@ -434,7 +448,7 @@ async function resolveWorkspaceHostApps(ws, opts = {}) {
       const match = previous.find((row) => row && row.id === app.id);
       return match ? { ...app, host: match.host === true || app.host === true } : app;
     });
-    ws.hostApps = result.apps;
+    ws.hostApps = listedHostApps(result.apps);
     if (opts.cfg) persistWorkspaceEntry(opts.cfg, ws);
     const summary = result.apps
       .map((app) => `${app.name}:${app.port}`)
@@ -455,19 +469,10 @@ async function resolveWorkspaceHostApps(ws, opts = {}) {
     activity(
       ws.sandboxId,
       "warn",
-      `port detect failed (${message}) — using AI server ${Number(ws.port) || 3100} so setup can continue`
+      `port detect failed (${message}) — no host apps listed yet`
     );
     if (!Array.isArray(ws.hostApps) || !ws.hostApps.length) {
-      ws.hostApps = [
-        {
-          id: "ai-server",
-          name: "AI server",
-          role: "ai-server",
-          port: Number(ws.port) || 3100,
-          source: "default",
-          locked: true,
-        },
-      ];
+      ws.hostApps = [];
     }
     return {
       apps: ws.hostApps,
@@ -763,8 +768,31 @@ function isLocalAppUrl(url) {
   }
 }
 
+function isAiServerApp(app) {
+  return Boolean(app && (app.role === "ai-server" || app.id === "ai-server"));
+}
+
+function listedHostApps(apps) {
+  return (Array.isArray(apps) ? apps : []).filter((app) => !isAiServerApp(app));
+}
+
+function stripAiServerFromWorkspace(ws) {
+  if (!ws || typeof ws !== "object") return ws;
+  if (Array.isArray(ws.hostApps)) ws.hostApps = listedHostApps(ws.hostApps);
+  if (ws.proxy && typeof ws.proxy === "object") {
+    if (ws.proxy.slugs && typeof ws.proxy.slugs === "object") {
+      delete ws.proxy.slugs["ai-server"];
+    }
+    if (ws.proxy.urls && typeof ws.proxy.urls === "object") {
+      delete ws.proxy.urls["ai-server"];
+    }
+  }
+  return ws;
+}
+
 function persistWorkspaceEntry(cfg, ws) {
   if (!cfg || !ws?.sandboxId) return;
+  stripAiServerFromWorkspace(ws);
   cfg.workspaces = cfg.workspaces || [];
   const index = cfg.workspaces.findIndex((row) => row.sandboxId === ws.sandboxId);
   if (index >= 0) cfg.workspaces[index] = { ...cfg.workspaces[index], ...ws };
@@ -1001,16 +1029,7 @@ function probeEmbedConfig(url, timeoutMs = 2500) {
 
 function sanitizeAiServerPort(ws) {
   if (!ws || typeof ws !== "object") return;
-  const apps = Array.isArray(ws.hostApps) ? ws.hostApps : [];
-  for (const app of apps) {
-    if (
-      app &&
-      (app.role === "ai-server" || app.id === "ai-server") &&
-      isAdminListenPort(app.port)
-    ) {
-      app.port = 3100;
-    }
-  }
+  if (Array.isArray(ws.hostApps)) ws.hostApps = listedHostApps(ws.hostApps);
   if (isAdminListenPort(ws.port)) ws.port = 3100;
 }
 
@@ -1304,10 +1323,6 @@ async function reconcileWorkspacePresence(ws, cfg, opts = {}) {
   // 3. Host + CORS origins for Maintainer Pro
   const host = workspaceHostReport(ws);
   const uiShare = proxyUrlForApp(ws, hostAppOf(ws) || { id: "ui", role: "ui", host: true });
-  const aiShare = proxyUrlForApp(ws, {
-    id: "ai-server",
-    role: "ai-server",
-  });
   if (uiShare) {
     host.appUrl = uiShare;
   } else if (probe.running) {
@@ -1316,12 +1331,9 @@ async function reconcileWorkspacePresence(ws, cfg, opts = {}) {
     );
     if (ui?.port) {
       host.appUrl = `http://localhost:${ui.port}`;
-    } else if (probe.chatUp) {
-      host.appUrl = `http://localhost:${probe.chatPort}`;
     }
   }
   if (uiShare && !host.origins.includes(uiShare)) host.origins.push(uiShare);
-  if (aiShare && !host.origins.includes(aiShare)) host.origins.push(aiShare);
   const proxyOrigin = String(ws?.proxy?.origin || "").replace(/\/$/, "");
   if (proxyOrigin && !host.origins.includes(proxyOrigin)) {
     host.origins.push(proxyOrigin);
@@ -1491,7 +1503,7 @@ function uniqueProxySlugs(apps) {
   const used = new Set();
   /** @type {Record<string, string>} */
   const slugs = {};
-  for (const app of apps || []) {
+  for (const app of listedHostApps(apps)) {
     let slug = proxySlugForApp(app);
     if (!slug || !app?.id) continue;
     if (used.has(slug)) {
@@ -1512,7 +1524,7 @@ function uniqueProxySlugs(apps) {
 }
 
 function sharePortUrls(ws) {
-  const apps = Array.isArray(ws?.hostApps) ? ws.hostApps : [];
+  const apps = listedHostApps(ws?.hostApps);
   /** @type {Record<string, string>} */
   const out = {};
   for (const app of apps) {
@@ -1547,8 +1559,10 @@ function applyAssignedProxy(ws, remote, cfg) {
 }
 
 function appsFrom(ws, remote) {
-  if (Array.isArray(ws?.hostApps) && ws.hostApps.length) return ws.hostApps;
-  if (Array.isArray(remote?.hostApps)) return remote.hostApps;
+  if (Array.isArray(ws?.hostApps) && ws.hostApps.length) {
+    return listedHostApps(ws.hostApps);
+  }
+  if (Array.isArray(remote?.hostApps)) return listedHostApps(remote.hostApps);
   return [];
 }
 
@@ -1569,10 +1583,9 @@ function proxyUrlForApp(ws, app) {
 }
 
 function jobsFromHostApps(ws, filter = {}) {
-  const apps = Array.isArray(ws.hostApps) ? ws.hostApps : [];
+  const apps = listedHostApps(ws.hostApps);
   const hostId = hostAppOf(ws)?.id;
   return apps
-    .filter((app) => app && app.role !== "ai-server")
     .filter((app) => (filter.appId ? app.id === filter.appId : true))
     .map((app) => {
       const port = Number(app.port) || 3000;
@@ -1622,7 +1635,7 @@ async function probeRunningApps(ws, timeoutMs = 2500) {
       appId: job.appId || job.role,
     });
   }
-  const listed = Array.isArray(ws.hostApps) ? ws.hostApps : [];
+  const listed = listedHostApps(ws.hostApps);
   const hostApps = await Promise.all(
     listed.map(async (app) => {
       const port = Number(app.port) || 0;
@@ -1645,7 +1658,7 @@ async function probeRunningApps(ws, timeoutMs = 2500) {
     chatPort: chat.port,
     hosts,
     hostApps,
-    running: chat.up || hosts.some((host) => host.up) || hostApps.some((app) => app.running),
+    running: hosts.some((host) => host.up) || hostApps.some((app) => app.running),
   };
 }
 
@@ -1662,9 +1675,7 @@ async function restoreHostsAfterReconnect(cfg) {
       .join(" ");
     if (status.appsRunning) {
       log(
-        `found running apps for ${label}: chat=${status.probe.chatPort}${
-          status.probe.chatUp ? "(up)" : "(down)"
-        }${hostSummary ? ` ${hostSummary}` : ""} share=${
+        `found running apps for ${label}: ${hostSummary || "(none)"} share=${
           status.host.appUrl || "(none)"
         } origins=${
           status.host.origins.join(",") || "none"
@@ -1703,10 +1714,7 @@ async function prepareWorkspaceLaunch(ws, cfg, reserved) {
     return { aiPort, jobs: [] };
   }
   log(`ports pick ${label} in ${folder}`);
-  const listedAi = Array.isArray(ws.hostApps)
-    ? ws.hostApps.find((app) => app.role === "ai-server" || app.id === "ai-server")
-    : null;
-  const preferredRaw = Number(listedAi?.port || ws.port) || 3100;
+  const preferredRaw = Number(ws.port) || 3100;
   const preferredAi = isAdminListenPort(preferredRaw) ? 3100 : preferredRaw;
   const aiUp = await isChatServerOnPort(preferredAi);
   const aiPort = aiUp
@@ -4679,12 +4687,11 @@ async function runActions(cfg, actions) {
               String(action.payload.folderPathRemaining || remaining[0] || ws.folderPath);
             ws.folderPath = primary;
             ws.extraFolders = remaining.filter((folder) => !sameFolder(folder, primary));
-            ws.hostApps = (Array.isArray(ws.hostApps) ? ws.hostApps : []).filter(
+            ws.hostApps = listedHostApps(
+              Array.isArray(ws.hostApps) ? ws.hostApps : []
+            ).filter(
               (app) =>
-                !app ||
-                app.role === "ai-server" ||
-                !app.folderPath ||
-                !sameFolder(app.folderPath, removed)
+                !app.folderPath || !sameFolder(app.folderPath, removed)
             );
             persistWorkspaceEntry(cfg, ws);
             result = {

package/src/share-rewrite.mjs

@@ -274,6 +274,33 @@ function mappedUrlForPort(portUrls, port) {
   return dest ? String(dest).replace(/\/$/, "") : "";
 }
 
+function backendShareBase(portUrls) {
+  if (!portUrls || typeof portUrls !== "object") return "";
+  for (const dest of Object.values(portUrls)) {
+    const url = String(dest || "").replace(/\/$/, "");
+    if (!url) continue;
+    try {
+      const slug = new URL(url).pathname.split("/").filter(Boolean)[2] || "";
+      if (slug === "backend" || slug.startsWith("backend-")) return url;
+    } catch {
+      if (/\/backend(?:-[^/]+)?$/i.test(url)) return url;
+    }
+  }
+  return "";
+}
+
+function shareBaseForPath(path, publicBase, portUrls) {
+  const pathname = String(path || "").split("?")[0] || "/";
+  if (
+    isShareAssetPath(pathname) ||
+    pathname.startsWith("/_next/") ||
+    pathname.startsWith("/@")
+  ) {
+    return publicBase;
+  }
+  return backendShareBase(portUrls) || publicBase;
+}
+
 function isProbablyUtf8Text(buf) {
   if (!Buffer.isBuffer(buf) || !buf.length || buf.length > 8 * 1024 * 1024) {
     return false;
@@ -347,7 +374,7 @@ export function rewriteMappedLocalUrls(text, portUrls) {
  * @param {Record<string, string>} headers
  * @param {Record<string, string> | null | undefined} portUrls
  */
-export function rewriteShareRequestBody(body, headers, portUrls, publicBase) {
+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;
@@ -357,7 +384,6 @@ export function rewriteShareRequestBody(body, headers, portUrls, publicBase) {
   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");
 }
@@ -411,7 +437,7 @@ function rewriteHeaderUrls(headers, publicBase, port, portUrls) {
       if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
         continue;
       }
-      headers[key] = rewriteShareOriginPaths(headers[key], publicBase);
+      headers[key] = rewriteShareOriginPaths(headers[key], publicBase, portUrls);
     }
   }
 }
@@ -449,7 +475,7 @@ export function prefixShareOriginUrl(value, publicBase) {
   }
 }
 
-export function rewriteShareOriginPaths(text, publicBase) {
+export function rewriteShareOriginPaths(text, publicBase, portUrls) {
   if (!text || !publicBase) return text;
   let origin = "";
   try {
@@ -462,15 +488,24 @@ export function rewriteShareOriginPaths(text, publicBase) {
   const originSlashEsc = origin
     .replace(/\//g, "\\/")
     .replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const baseFor = function (matched) {
+    let path = "/";
+    try {
+      path = new URL(matched).pathname || "/";
+    } catch {
+      /* keep */
+    }
+    return shareBaseForPath(path, publicBase, portUrls);
+  };
   let out = String(text);
   out = out.replace(new RegExp(originEsc + "/(?!p/)[^\\s'\"<>\\\\]+", "gi"), function (matched) {
-    return prefixShareOriginUrl(matched, publicBase);
+    return prefixShareOriginUrl(matched, baseFor(matched));
   });
   out = out.replace(
     new RegExp(originSlashEsc + "\\\\/(?!p/)[^\\s'\"<>]+", "gi"),
     function (matched) {
       const unescaped = matched.replace(/\\\//g, "/");
-      return prefixShareOriginUrl(unescaped, publicBase).replace(/\//g, "\\/");
+      return prefixShareOriginUrl(unescaped, baseFor(unescaped)).replace(/\//g, "\\/");
     }
   );
   return out;
@@ -496,7 +531,18 @@ function rewriteLocation(value, publicBase, port, portUrls) {
     }
     const fromPorts = rewriteMappedLocalUrls(String(value), portUrls);
     if (fromPorts !== String(value)) return fromPorts;
-    if (publicBase) return prefixShareOriginUrl(String(value), publicBase);
+    if (publicBase) {
+      let path = "/";
+      try {
+        path = new URL(String(value)).pathname || "/";
+      } catch {
+        /* keep */
+      }
+      return prefixShareOriginUrl(
+        String(value),
+        shareBaseForPath(path, publicBase, portUrls)
+      );
+    }
   } catch {
     /* keep */
   }
@@ -809,12 +855,11 @@ function prefixRootPaths(body, publicBase, contentType = "") {
   let out = body;
   if (
     html &&
+    isViteDocument(out) &&
     /<head[\s>]/i.test(out) &&
-    !/<base\s/i.test(out) &&
-    !isNextDocument(out)
+    !/<base\s/i.test(out)
   ) {
-    const viteBase = isViteDocument(out) ? inferViteBase(out) : "/";
-    const href = joinProxyAndViteBase(pathPrefix, viteBase);
+    const href = joinProxyAndViteBase(pathPrefix, inferViteBase(out));
     out = out.replace(/<head([^>]*)>/i, `<head$1><base href="${href}">`);
   }
   if (html) {
@@ -871,6 +916,12 @@ function isScriptRequestPath(path) {
   return /\.(?:m?js|cjs)$/.test(p);
 }
 
+function isScriptOrJsonBody(headers, path) {
+  const mime = contentMime(headerGet(headers, "content-type"));
+  if (/javascript|ecmascript|json/.test(mime)) return true;
+  return isScriptRequestPath(path);
+}
+
 function rewriteLocalSidecarUrls(html, aiPublicBase, uiPublicBase) {
   const ai = String(aiPublicBase || "").replace(/\/$/, "");
   const ui = String(uiPublicBase || "").replace(/\/$/, "");
@@ -968,6 +1019,14 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
       )
     );
   }
+  function loopback(h) {
+    h = String(h || "")
+      .replace(/^\[|\]$/g, "")
+      .toLowerCase();
+    return (
+      h === "localhost" || h === "127.0.0.1" || h === "::1" || h === "0.0.0.0"
+    );
+  }
   function prefixPath(path) {
     if (typeof path !== "string" || !path) return path;
     if (path.charAt(0) === "/" && path.charAt(1) !== "/") {
@@ -1005,12 +1064,29 @@ function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
     } catch (e) {}
     return v;
   }
+  function backendBase() {
+    var map = portMap || {};
+    var keys = Object.keys(map);
+    for (var i = 0; i < keys.length; i++) {
+      var url = String(map[keys[i]] || "").replace(/\/$/, "");
+      if (!url) continue;
+      try {
+        var slug = new URL(url).pathname.split("/").filter(Boolean)[2] || "";
+        if (slug === "backend" || slug.indexOf("backend-") === 0) return url;
+      } catch (e) {
+        if (/\/backend(?:-[^/]+)?$/i.test(url)) return url;
+      }
+    }
+    return "";
+  }
   function addNav(v) {
     if (typeof v !== "string" || !v) return v;
-    v = mapLocal(v);
+    var mapped = mapLocal(v);
+    if (mapped !== v) return mapped;
     if (v.charAt(0) === "/" && v.charAt(1) !== "/") return prefixPath(v);
     try {
       var nav = new URL(v, location.href);
+      if (!loopback(nav.hostname)) return v;
       if (nav.origin !== location.origin) return v;
       if (nav.pathname === "/" || nav.pathname === "") return v;
       nav.pathname = prefixPath(nav.pathname);
@@ -1019,6 +1095,46 @@ 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;
+    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;
+        }
+        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);
+    }
+    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;
+    }
     return addNav(v);
   }
   function mapSel(sel) {
@@ -1213,13 +1329,62 @@ function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
     } catch (e) {}
     return "";
   }
+  function loopback(h) {
+    h = String(h || "")
+      .replace(/^\[|\]$/g, "")
+      .toLowerCase();
+    return (
+      h === "localhost" || h === "127.0.0.1" || h === "::1" || h === "0.0.0.0"
+    );
+  }
+  function backendBase() {
+    var map = portMap || {};
+    var keys = Object.keys(map);
+    for (var i = 0; i < keys.length; i++) {
+      var url = String(map[keys[i]] || "").replace(/\/$/, "");
+      if (!url) continue;
+      try {
+        var slug = new URL(url).pathname.split("/").filter(Boolean)[2] || "";
+        if (slug === "backend" || slug.indexOf("backend-") === 0) return url;
+      } catch (e) {
+        if (/\/backend(?:-[^/]+)?$/i.test(url)) return url;
+      }
+    }
+    return "";
+  }
   function prefixWith(url, prefix) {
     if (!prefix) return url;
     try {
-      var u = new URL(url, self.location.href);
+      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;
+      }
+      var path = parsed.pathname || "/";
+      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)
+      ) {
+        var dest = backend + path + (parsed.search || "") + (parsed.hash || "");
+        if (/^ws/i.test(parsed.protocol)) dest = dest.replace(/^http/i, "ws");
+        return dest;
+      }
+      var u = parsed;
       if (u.origin !== self.location.origin) return url;
       if (u.pathname === "/" || u.pathname === "") 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();
@@ -1393,7 +1558,7 @@ export function processShareHttpResponse(opts) {
     }
   }
   if (publicBase && rewriteTextBody) {
-    const prefixed = rewriteShareOriginPaths(text, publicBase);
+    const prefixed = rewriteShareOriginPaths(text, publicBase, portUrls);
     if (prefixed !== text) {
       text = prefixed;
       mutated = true;