@nextop-os/browser-node 0.0.14 → 0.0.16

package/dist/electron-main/index.js

@@ -3,15 +3,460 @@ import {
   resolveBrowserNavigationUrl
 } from "../chunk-2ZAMKGGP.js";
 import {
-  isBrowserSessionPartitionAllowed
+  isBrowserSessionPartitionAllowed,
+  resolveBrowserSessionPartition
 } from "../chunk-OTK5YBCK.js";
 
-// src/electron-main/previewRoute.ts
-function createNoopBrowserNodePreviewRouteResolver() {
+// src/electron-main/loopbackPreviewProxy.ts
+import {
+  createServer,
+  request as httpRequest
+} from "http";
+import { request as httpsRequest } from "https";
+import { createRequire } from "module";
+import { pipeline } from "stream";
+var require2 = createRequire(import.meta.url);
+var wsModule = require2("ws");
+var WebSocket = wsModule;
+var { WebSocketServer } = wsModule;
+var defaultLoopbackPreviewCacheTtlMs = 3e4;
+var loopbackHostPattern = /^(localhost|127(?:\.\d{1,3}){0,3})$/i;
+var hopByHopHeaders = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function createBrowserNodeLoopbackPreviewProxy({
+  logger,
+  resolveSession,
+  routing
+}) {
+  const configuredSessions = /* @__PURE__ */ new WeakSet();
+  const targetCache = /* @__PURE__ */ new Map();
+  const downstreamWebSocketServer = new WebSocketServer({ noServer: true });
+  let server = null;
+  let serverStartPromise = null;
+  const cacheTtlMs = routing.cacheTtlMs ?? defaultLoopbackPreviewCacheTtlMs;
+  const fallback = routing.fallback ?? "direct";
+  const pruneExpiredTargets = (now) => {
+    for (const [cacheKey, cachedTarget] of targetCache.entries()) {
+      if (cachedTarget.expiresAt <= now) {
+        targetCache.delete(cacheKey);
+      }
+    }
+  };
+  const start = async () => {
+    if (server?.listening) {
+      return addressForTesting();
+    }
+    if (serverStartPromise) {
+      return serverStartPromise;
+    }
+    serverStartPromise = new Promise((resolve, reject) => {
+      const nextServer = createServer((request, response) => {
+        void handleRequest(request, response);
+      });
+      nextServer.on("upgrade", (request, socket, head) => {
+        void handleUpgrade(request, socket, head);
+      });
+      const cleanup = () => {
+        nextServer.removeListener("error", onError);
+        nextServer.removeListener("listening", onListening);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const onListening = () => {
+        cleanup();
+        server = nextServer;
+        resolve(addressForTesting());
+      };
+      nextServer.once("error", onError);
+      nextServer.once("listening", onListening);
+      nextServer.listen(0, "127.0.0.1");
+    }).finally(() => {
+      serverStartPromise = null;
+    });
+    return serverStartPromise;
+  };
+  const resolveLoopbackTarget = async (originalUrl) => {
+    const port = Number(originalUrl.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      return null;
+    }
+    const now = Date.now();
+    pruneExpiredTargets(now);
+    const cacheKey = originalUrl.toString();
+    const cached = targetCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.target;
+    }
+    const nextTarget = await Promise.resolve(
+      routing.resolver.resolveTarget({
+        port,
+        url: originalUrl.toString()
+      })
+    );
+    const target = normalizeLoopbackPreviewTarget(nextTarget);
+    targetCache.set(cacheKey, {
+      expiresAt: now + Math.max(0, cacheTtlMs),
+      target
+    });
+    return target;
+  };
+  const configureSession = async (input) => {
+    const nextSession = await resolveSession(input);
+    if (configuredSessions.has(nextSession)) {
+      return;
+    }
+    const address = await start();
+    await nextSession.setProxy({
+      mode: "fixed_servers",
+      proxyBypassRules: "<-loopback>",
+      proxyRules: `http=${address};https=${address};ws=${address}`
+    });
+    configuredSessions.add(nextSession);
+  };
+  const dispose = async () => {
+    targetCache.clear();
+    downstreamWebSocketServer.close();
+    const activeServer = server;
+    server = null;
+    if (!activeServer || !activeServer.listening) {
+      return;
+    }
+    await new Promise((resolve) => {
+      activeServer.close(() => resolve());
+    });
+  };
+  const handleRequest = async (request, response) => {
+    const originalUrl = resolveProxyRequestUrl(request);
+    if (!originalUrl) {
+      response.writeHead(400);
+      response.end("invalid proxy request");
+      return;
+    }
+    if (originalUrl.protocol !== "http:" && originalUrl.protocol !== "https:") {
+      response.writeHead(400);
+      response.end("unsupported proxy request");
+      return;
+    }
+    const targetContext = await resolveTargetRequestContext(originalUrl);
+    if (!targetContext.targetUrl) {
+      response.writeHead(502);
+      response.end("unable to resolve loopback preview target");
+      return;
+    }
+    const headers = filterProxyHeaders(request.headers);
+    headers.set("host", targetContext.targetUrl.host);
+    const forward = targetContext.targetUrl.protocol === "https:" ? httpsRequest : httpRequest;
+    const upstream = forward(
+      targetContext.targetUrl,
+      {
+        headers: Object.fromEntries(headers.entries()),
+        method: request.method
+      },
+      (upstreamResponse) => {
+        const responseHeaders = filterProxyHeaders(upstreamResponse.headers);
+        const location = responseHeaders.get("location");
+        if (location && targetContext.loopbackTarget) {
+          const rewritten = rewriteLoopbackLocation({
+            location,
+            originalUrl,
+            targetUrl: targetContext.loopbackTarget.targetUrl
+          });
+          if (rewritten) {
+            responseHeaders.set("location", rewritten);
+          }
+        }
+        response.writeHead(
+          upstreamResponse.statusCode ?? 502,
+          upstreamResponse.statusMessage,
+          Object.fromEntries(responseHeaders.entries())
+        );
+        pipeline(upstreamResponse, response, () => void 0);
+      }
+    );
+    upstream.on("error", (error) => {
+      logger?.warn?.("Browser Node loopback preview request failed", {
+        error: normalizeProxyError(error),
+        originalUrl: originalUrl.toString(),
+        targetUrl: targetContext.targetUrl?.toString() ?? null,
+        workspaceId: targetContext.loopbackTarget?.workspaceId ?? null
+      });
+      if (!response.headersSent) {
+        response.writeHead(502);
+      }
+      response.end(
+        `loopback preview upstream request failed: ${normalizeProxyError(error)}`
+      );
+    });
+    pipeline(request, upstream, () => void 0);
+  };
+  const handleUpgrade = async (request, socket, head) => {
+    const originalUrl = resolveProxyRequestUrl(request, "ws:");
+    if (!originalUrl) {
+      socket.destroy();
+      return;
+    }
+    if (originalUrl.protocol !== "ws:" && originalUrl.protocol !== "wss:") {
+      socket.destroy();
+      return;
+    }
+    const targetContext = await resolveTargetRequestContext(originalUrl);
+    const targetUrl = targetContext.targetUrl;
+    if (!targetUrl) {
+      socket.destroy();
+      return;
+    }
+    downstreamWebSocketServer.handleUpgrade(
+      request,
+      socket,
+      head,
+      (downstream) => {
+        const headers = Object.fromEntries(
+          filterProxyHeaders(request.headers).entries()
+        );
+        headers.host = targetUrl.host;
+        const upstream = new WebSocket(targetUrl, { headers });
+        const pendingMessages = [];
+        downstream.on("message", (data, isBinary) => {
+          if (upstream.readyState === WebSocket.OPEN) {
+            upstream.send(data, { binary: isBinary });
+            return;
+          }
+          pendingMessages.push({ data, isBinary });
+        });
+        upstream.once("open", () => {
+          for (const nextMessage of pendingMessages.splice(0)) {
+            upstream.send(nextMessage.data, { binary: nextMessage.isBinary });
+          }
+        });
+        upstream.on("message", (data, isBinary) => {
+          if (downstream.readyState === WebSocket.OPEN) {
+            downstream.send(data, { binary: isBinary });
+          }
+        });
+        upstream.once("close", (code, reason) => {
+          if (downstream.readyState === WebSocket.OPEN || downstream.readyState === WebSocket.CONNECTING) {
+            downstream.close(normalizeWebSocketCloseCode(code), reason);
+          }
+        });
+        downstream.once("close", (code, reason) => {
+          if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+            upstream.close(normalizeWebSocketCloseCode(code), reason);
+          }
+        });
+        upstream.once("error", (error) => {
+          logger?.warn?.("Browser Node loopback preview websocket failed", {
+            error: normalizeProxyError(error),
+            originalUrl: originalUrl.toString(),
+            targetUrl: targetContext.targetUrl?.toString() ?? null,
+            workspaceId: targetContext.loopbackTarget?.workspaceId ?? null
+          });
+          downstream.close(1011, "loopback preview websocket upstream failed");
+        });
+      }
+    );
+  };
+  const resolveTargetRequestContext = async (originalUrl) => {
+    if (!isLoopbackUrl(originalUrl)) {
+      return {
+        loopbackTarget: null,
+        targetUrl: cloneUrl(originalUrl)
+      };
+    }
+    const loopbackTarget = await resolveLoopbackTarget(originalUrl);
+    if (loopbackTarget) {
+      return {
+        loopbackTarget,
+        targetUrl: buildTargetRequestUrl(loopbackTarget.targetUrl, originalUrl)
+      };
+    }
+    if (fallback === "direct") {
+      return {
+        loopbackTarget: null,
+        targetUrl: cloneUrl(originalUrl)
+      };
+    }
+    return {
+      loopbackTarget: null,
+      targetUrl: null
+    };
+  };
+  const addressForTesting = () => {
+    const address = server?.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Browser Node loopback preview proxy is not listening");
+    }
+    return `127.0.0.1:${address.port}`;
+  };
+  const serverForTesting = () => {
+    if (!server) {
+      throw new Error("Browser Node loopback preview proxy is not started");
+    }
+    return server;
+  };
   return {
-    resolveRoutes: () => []
+    addressForTesting,
+    configureSession,
+    dispose,
+    serverForTesting
   };
 }
+function normalizeLoopbackPreviewTarget(input) {
+  if (!input) {
+    return null;
+  }
+  const normalizedTargetUrl = input.targetUrl.trim();
+  if (normalizedTargetUrl.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = new URL(normalizedTargetUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return {
+      targetUrl: parsed.toString(),
+      workspaceId: input.workspaceId
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveProxyRequestUrl(request, defaultProtocol = "http:") {
+  const rawUrl = request.url ?? "";
+  try {
+    if (/^[a-z][a-z\d+\-.]*:\/\//i.test(rawUrl)) {
+      return new URL(rawUrl);
+    }
+    const host = request.headers.host;
+    if (typeof host !== "string" || host.trim().length === 0) {
+      return null;
+    }
+    const path = rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+    return new URL(`${defaultProtocol}//${host}${path}`);
+  } catch {
+    return null;
+  }
+}
+function filterProxyHeaders(input) {
+  const output = new Headers();
+  const appendValue = (key, value) => {
+    if (hopByHopHeaders.has(key.toLowerCase())) {
+      return;
+    }
+    output.append(key, value);
+  };
+  if (input instanceof Headers) {
+    input.forEach((value, key) => {
+      appendValue(key, value);
+    });
+    return output;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    if (Array.isArray(value)) {
+      for (const nextValue of value) {
+        appendValue(key, nextValue);
+      }
+      continue;
+    }
+    if (typeof value === "string") {
+      appendValue(key, value);
+    }
+  }
+  return output;
+}
+function isLoopbackUrl(url) {
+  return (url.protocol === "http:" || url.protocol === "https:" || url.protocol === "ws:" || url.protocol === "wss:") && loopbackHostPattern.test(url.hostname) && url.port.length > 0;
+}
+function buildTargetRequestUrl(targetUrl, originalUrl) {
+  try {
+    const base = new URL(targetUrl);
+    const normalizedBasePath = normalizeBasePath(base.pathname);
+    const nextUrl = new URL(base.toString());
+    nextUrl.pathname = joinBasePath(normalizedBasePath, originalUrl.pathname);
+    nextUrl.search = originalUrl.search;
+    nextUrl.hash = "";
+    if (originalUrl.protocol === "ws:" || originalUrl.protocol === "wss:") {
+      nextUrl.protocol = nextUrl.protocol === "https:" ? "wss:" : "ws:";
+    }
+    return nextUrl;
+  } catch {
+    return null;
+  }
+}
+function rewriteLoopbackLocation({
+  location,
+  originalUrl,
+  targetUrl
+}) {
+  try {
+    const targetBase = new URL(targetUrl);
+    const resolvedLocation = new URL(location, targetBase);
+    if (resolvedLocation.origin !== targetBase.origin) {
+      return location;
+    }
+    const basePath = normalizeBasePath(targetBase.pathname);
+    const strippedPath = stripBasePath(basePath, resolvedLocation.pathname) ?? resolvedLocation.pathname;
+    const loopbackUrl = new URL(originalUrl.origin);
+    resolvedLocation.protocol = loopbackUrl.protocol;
+    resolvedLocation.host = loopbackUrl.host;
+    resolvedLocation.pathname = strippedPath;
+    resolvedLocation.username = "";
+    resolvedLocation.password = "";
+    return resolvedLocation.toString();
+  } catch {
+    return location;
+  }
+}
+function normalizeBasePath(pathname) {
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function joinBasePath(basePath, requestPath) {
+  const normalizedRequestPath = requestPath === "/" ? "" : requestPath.replace(/^\/+/, "");
+  return normalizedRequestPath.length > 0 ? `${basePath}${normalizedRequestPath}`.replace(/\/{2,}/g, "/") : basePath;
+}
+function stripBasePath(basePath, pathname) {
+  const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (normalizedPath === basePath.slice(0, -1)) {
+    return "/";
+  }
+  if (!normalizedPath.startsWith(basePath)) {
+    return null;
+  }
+  const suffix = normalizedPath.slice(basePath.length);
+  return suffix.length > 0 ? `/${suffix}` : "/";
+}
+function cloneUrl(url) {
+  try {
+    return new URL(url.toString());
+  } catch {
+    return null;
+  }
+}
+function normalizeProxyError(error) {
+  if (error instanceof Error) {
+    const code = typeof error.code === "string" ? ` ${error.code}` : "";
+    return `${error.message}${code}`;
+  }
+  return String(error);
+}
+function normalizeWebSocketCloseCode(code) {
+  if (code === 1e3 || code >= 3e3 && code <= 4999) {
+    return code;
+  }
+  return 1e3;
+}
 
 // src/electron-main/guestManager.ts
 var browserPreviewMaxWidth = 260;
@@ -54,15 +499,37 @@ function resizeBrowserPreviewImage(image) {
 function isAbortedNavigationError(input) {
   return input.errorCode === abortedNavigationErrorCode || input.errorDescription === "ERR_ABORTED";
 }
+async function applyPreferredColorSchemeToGuest(session, logger, syncPreferredColorScheme, scheme) {
+  const contents = session.contents;
+  if (!contents || contents.isDestroyed() || !syncPreferredColorScheme || scheme === null || session.appliedColorScheme === scheme) {
+    return;
+  }
+  try {
+    await syncPreferredColorScheme(contents, scheme);
+    session.appliedColorScheme = scheme;
+  } catch (error) {
+    session.appliedColorScheme = null;
+    logger?.warn?.("Browser Node failed to sync guest color scheme", {
+      error: error instanceof Error ? error.message : String(error),
+      nodeId: session.nodeId,
+      scheme,
+      webContentsId: session.webContentsId
+    });
+  }
+}
 function createBrowserGuestManager({
   emit,
+  getPreferredColorScheme,
   logger,
   openExternal,
-  previewRouteResolver = createNoopBrowserNodePreviewRouteResolver(),
-  resolveWebContents
+  prepareSession,
+  resolveWebContents,
+  syncPreferredColorScheme,
+  subscribePreferredColorScheme
 }) {
   const sessions = /* @__PURE__ */ new Map();
   const nodeIdByWebContentsId = /* @__PURE__ */ new Map();
+  let preferredColorScheme = getPreferredColorScheme?.() ?? null;
   const getSession = (nodeId, input) => {
     const existing = sessions.get(nodeId);
     if (existing) {
@@ -78,6 +545,7 @@ function createBrowserGuestManager({
       return existing;
     }
     const session = {
+      appliedColorScheme: null,
       contents: null,
       desiredUrl: input?.url ?? "about:blank",
       lifecycle: "cold",
@@ -115,12 +583,26 @@ function createBrowserGuestManager({
     }
     session.listeners = [];
     session.contents = null;
+    session.appliedColorScheme = null;
     session.webContentsId = null;
     if (webContentsId !== null && nodeIdByWebContentsId.get(webContentsId) === session.nodeId) {
       nodeIdByWebContentsId.delete(webContentsId);
     }
     publishState(session);
   };
+  const handlePreferredColorSchemeChange = (scheme) => {
+    preferredColorScheme = scheme;
+    for (const session of sessions.values()) {
+      session.appliedColorScheme = null;
+      void applyPreferredColorSchemeToGuest(
+        session,
+        logger,
+        syncPreferredColorScheme,
+        scheme
+      ).catch(() => void 0);
+    }
+  };
+  const unsubscribePreferredColorScheme = subscribePreferredColorScheme?.(handlePreferredColorSchemeChange) ?? null;
   const attachGuestListeners = (session) => {
     const contents = session.contents;
     if (!contents) {
@@ -174,18 +656,13 @@ function createBrowserGuestManager({
       publishState(session);
       return;
     }
-    const routes = await previewRouteResolver.resolveRoutes({
-      nodeId: session.nodeId,
-      url: resolved.url
-    });
-    const routedUrl = routes.find((route) => route.sourceUrl === resolved.url)?.targetUrl ?? resolved.url;
     const currentComparable = normalizeBrowserComparableUrl(contents.getURL());
-    const nextComparable = normalizeBrowserComparableUrl(routedUrl);
+    const nextComparable = normalizeBrowserComparableUrl(resolved.url);
     if (currentComparable && currentComparable === nextComparable) {
       publishState(session);
       return;
     }
-    await contents.loadURL(routedUrl);
+    await contents.loadURL(resolved.url);
     publishState(session);
   };
   const openExternalFromGuest = (url) => {
@@ -281,14 +758,19 @@ function createBrowserGuestManager({
       session.lifecycle = "active";
       await loadDesiredUrl(session);
     },
-    prepareSession(input) {
+    async prepareSession(input) {
+      await prepareSession?.(input);
       getSession(input.nodeId, {
         profileId: input.profileId,
         sessionMode: input.sessionMode
       });
-      return Promise.resolve();
     },
     async registerGuest(input) {
+      await prepareSession?.({
+        nodeId: input.nodeId,
+        profileId: input.profileId,
+        sessionMode: input.sessionMode
+      });
       const contents = resolveWebContents(input.webContentsId);
       if (!contents || contents.isDestroyed()) {
         throw new Error(
@@ -318,6 +800,12 @@ function createBrowserGuestManager({
       session.lifecycle = "active";
       contents.setWindowOpenHandler?.(({ url }) => openExternalFromGuest(url));
       attachGuestListeners(session);
+      await applyPreferredColorSchemeToGuest(
+        session,
+        logger,
+        syncPreferredColorScheme,
+        preferredColorScheme
+      );
       await loadDesiredUrl(session);
     },
     reload(input) {
@@ -335,6 +823,9 @@ function createBrowserGuestManager({
       session.lifecycle = "cold";
       detachGuest(session);
       return Promise.resolve();
+    },
+    dispose() {
+      unsubscribePreferredColorScheme?.();
     }
   };
 }
@@ -342,6 +833,19 @@ function createBrowserGuestManager({
 // src/electron-main/registerElectronMain.ts
 function registerBrowserNodeElectronMain(input) {
   const managersByWindow = /* @__PURE__ */ new WeakMap();
+  const loopbackPreviewProxy = input.loopbackPreviewRouting !== void 0 ? createBrowserNodeLoopbackPreviewProxy({
+    logger: input.logger,
+    resolveSession: async ({ profileId, sessionMode }) => {
+      const { session } = await import("electron");
+      return session.fromPartition(
+        resolveBrowserSessionPartition({
+          profileId,
+          sessionMode
+        })
+      );
+    },
+    routing: input.loopbackPreviewRouting
+  }) : null;
   const resolveManager = (event) => {
     const ownerWindow = input.getOwnerWindow(event);
     if (!ownerWindow) {
@@ -357,13 +861,21 @@ function registerBrowserNodeElectronMain(input) {
           ownerWindow.webContents.send(input.channels.event, browserEvent);
         }
       },
+      getPreferredColorScheme: input.getPreferredColorScheme,
       logger: input.logger,
       openExternal: input.openExternal,
+      prepareSession: loopbackPreviewProxy !== null ? (payload) => loopbackPreviewProxy.configureSession(payload) : void 0,
       resolveWebContents: (webContentsId) => input.resolveWebContents({
         event,
         ownerWindow,
         webContentsId
-      })
+      }),
+      syncPreferredColorScheme: input.syncPreferredColorScheme,
+      subscribePreferredColorScheme: input.subscribePreferredColorScheme
+    });
+    ownerWindow.once("closed", () => {
+      manager.dispose();
+      managersByWindow.delete(ownerWindow);
     });
     managersByWindow.set(ownerWindow, manager);
     return manager;
@@ -499,8 +1011,6 @@ function installBrowserWebviewSecurity({
   };
 }
 export {
-  createBrowserGuestManager,
-  createNoopBrowserNodePreviewRouteResolver,
   enforceBrowserWebviewSecurity,
   installBrowserWebviewSecurity,
   isBrowserNodeWebviewAttach,