@salesforce/webapp-experimental 1.80.1 → 1.82.0

package/dist/proxy/handler.js

@@ -1,564 +1,503 @@
-/**
- * Copyright (c) 2026, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-import { createRequire } from "node:module";
-import { getLivePreviewScriptContent, LIVE_PREVIEW_SCRIPT_MARKER } from "./livePreviewScript.js";
+import { LIVE_PREVIEW_SCRIPT_MARKER, getLivePreviewScriptContent } from "./livePreviewScript.js";
 import { applyTrailingSlash, matchRoute } from "./routing.js";
-import { refreshOrgAuth } from "../app/index.js";
-const require = createRequire(import.meta.url);
-const { version: proxyVersion } = require("../../package.json");
-/**
- * URL parameter to trigger health check response
- */
-export const WEBAPP_HEALTH_CHECK_PARAM = "sfProxyHealthCheck";
-/**
- * Response header indicating the proxy is active
- */
-export const WEBAPP_PROXY_HEADER = "X-Salesforce-WebApp-Proxy";
-/**
- * Endpoint for Lightning Out frontdoor URL generation
- */
+import { version } from "../package.json.js";
+import { refreshOrgAuth } from "../app/org.js";
+import "node:fs/promises";
+const WEBAPP_HEALTH_CHECK_PARAM = "sfProxyHealthCheck";
+const WEBAPP_PROXY_HEADER = "X-Salesforce-WebApp-Proxy";
 const LIGHTNING_OUT_SINGLE_ACCESS_PATH = "/services/oauth2/singleaccess";
 const SALESFORCE_API_PREFIXES = ["/services/", "/lwr/apex/"];
 const AUTH_FAILED_RESPONSE = {
-    error: "AUTHENTICATION_FAILED",
-    message: "Authentication failed. Please re-authenticate to your Salesforce org.",
-    status: 401,
+  error: "AUTHENTICATION_FAILED",
+  message: "Authentication failed. Please re-authenticate to your Salesforce org.",
+  status: 401
 };
-/**
- * Thrown when a Salesforce authentication operation fails
- * (e.g. token refresh failure, missing credentials).
- * Caught in request handlers to return a 401 response.
- */
 class AuthenticationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "AuthenticationError";
-    }
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
 }
-/**
- * Handles all proxy routing and forwarding for WebApps
- */
 class WebAppProxyHandler {
-    manifest;
-    orgInfo;
-    target;
-    basePath;
-    options;
-    startTime = Date.now();
-    constructor(manifest, orgInfo, target, basePath, options) {
-        this.manifest = manifest;
-        this.orgInfo = orgInfo;
-        this.target = target;
-        this.basePath = basePath;
-        this.options = options;
+  constructor(manifest, orgInfo, target, basePath, options) {
+    this.manifest = manifest;
+    this.orgInfo = orgInfo;
+    this.target = target;
+    this.basePath = basePath;
+    this.options = options;
+  }
+  startTime = Date.now();
+  async handle(req, res, next) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.searchParams.get(WEBAPP_HEALTH_CHECK_PARAM) === "true") {
+      this.handleHealthCheck(res);
+      return;
     }
-    async handle(req, res, next) {
-        const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-        // Health check via URL parameter - respond immediately
-        if (url.searchParams.get(WEBAPP_HEALTH_CHECK_PARAM) === "true") {
-            this.handleHealthCheck(res);
-            return;
-        }
-        let pathname = url.pathname;
-        if (pathname === "/__lo/frontdoor") {
-            await this.handleLightningOutFrontdoor(req, res, url);
-            return;
-        }
+    let pathname = url.pathname;
+    if (pathname === "/__lo/frontdoor") {
+      await this.handleLightningOutFrontdoor(req, res, url);
+      return;
+    }
+    if (this.options?.debug) {
+      console.log(`[webapps-proxy] ${req.method} ${pathname}`);
+    }
+    pathname = applyTrailingSlash(pathname, this.manifest.routing?.trailingSlash);
+    const match = matchRoute(
+      pathname,
+      this.basePath,
+      this.manifest.routing?.rewrites,
+      this.manifest.routing?.redirects
+    );
+    if (match) {
+      if (match.type === "api") {
+        await this.handleSalesforceApi(req, res);
+        return;
+      }
+      if (match.type === "gql") {
+        await this.handleGraphQL(req, res);
+        return;
+      }
+      if (match.type === "redirect" && match.target && match.statusCode) {
+        this.handleRedirect(res, match.target, match.statusCode);
+        return;
+      }
+      if (match.type === "rewrite" && match.target) {
+        url.pathname = `/${match.target}`.replace(/\/+/g, "/");
+        req.url = url.pathname + url.search;
         if (this.options?.debug) {
-            console.log(`[webapps-proxy] ${req.method} ${pathname}`);
-        }
-        pathname = applyTrailingSlash(pathname, this.manifest.routing?.trailingSlash);
-        const match = matchRoute(pathname, this.basePath, this.manifest.routing?.rewrites, this.manifest.routing?.redirects);
-        if (match) {
-            if (match.type === "api") {
-                await this.handleSalesforceApi(req, res);
-                return;
-            }
-            if (match.type === "gql") {
-                await this.handleGraphQL(req, res);
-                return;
-            }
-            if (match.type === "redirect" && match.target && match.statusCode) {
-                this.handleRedirect(res, match.target, match.statusCode);
-                return;
-            }
-            if (match.type === "rewrite" && match.target) {
-                url.pathname = `/${match.target}`.replace(/\/+/g, "/");
-                req.url = url.pathname + url.search;
-                if (this.options?.debug) {
-                    console.log(`[webapps-proxy] Rewrite to ${req.url}`);
-                }
-                // After rewrite, let Vite handle the rewritten request (or forward to dev server if no next)
-                if (next) {
-                    next();
-                    return;
-                }
-                await this.forwardToDevServer(req, res);
-                return;
-            }
-            if (match.type === "file-upload") {
-                console.log("[webapps-proxy] file-upload match found → handleFileUpload");
-                await this.handleFileUpload(req, res, url);
-                return;
-            }
+          console.log(`[webapps-proxy] Rewrite to ${req.url}`);
         }
-        // Check if this is a Salesforce API request that needs proxying
-        if (SALESFORCE_API_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
-            await this.handleSalesforceApi(req, res);
-            return;
-        }
-        // For all other requests (static assets, HMR, HTML), let Vite handle them directly
-        // Note: In Vite middleware mode, HTML script injection is handled by
-        // the Vite plugin's transformIndexHtml hook, not here.
         if (next) {
-            next();
-        }
-        else {
-            await this.forwardToDevServer(req, res);
+          next();
+          return;
         }
+        await this.forwardToDevServer(req, res);
+        return;
+      }
+      if (match.type === "file-upload") {
+        console.log("[webapps-proxy] file-upload match found → handleFileUpload");
+        await this.handleFileUpload(req, res, url);
+        return;
+      }
     }
-    async forwardToDevServer(req, res) {
-        try {
-            const baseUrl = this.target ?? `http://${req.headers.host ?? "localhost"}`;
-            const url = new URL(req.url ?? "/", baseUrl);
-            if (this.options?.debug) {
-                console.log(`[webapps-proxy] Forwarding to dev server: ${url.href}`);
-            }
-            const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : undefined;
-            const response = await fetch(url.href, {
-                method: req.method,
-                headers: getFilteredHeaders(req.headers),
-                body: body,
-            });
-            await this.sendResponse(res, response);
-        }
-        catch (error) {
-            console.error("[webapps-proxy] Dev server request failed:", error);
-            this.sendAuthOrGatewayError(res, error, "Failed to forward request to dev server");
-        }
+    if (SALESFORCE_API_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
+      await this.handleSalesforceApi(req, res);
+      return;
     }
-    handleRedirect(res, location, statusCode) {
-        res.writeHead(statusCode, { Location: location });
-        res.end();
+    if (next) {
+      next();
+    } else {
+      await this.forwardToDevServer(req, res);
     }
-    handleHealthCheck(res) {
-        const response = {
-            proxyName: "@salesforce/webapp-experimental",
-            proxyVersion,
-            port: this.target ? new URL(this.target).port : undefined,
-            org: this.orgInfo?.orgAlias ?? this.orgInfo?.username,
-            apiVersion: this.orgInfo?.apiVersion,
-            webappName: this.manifest.name,
-            webappFolderPath: this.basePath,
-            uptime: Date.now() - this.startTime,
-            timestamp: new Date().toISOString(),
-            debugMode: this.options?.debug ?? false,
-        };
-        res.writeHead(200, {
-            "Content-Type": "application/json",
-            [WEBAPP_PROXY_HEADER]: "true",
-        });
-        res.end(JSON.stringify(response, null, 2));
+  }
+  async forwardToDevServer(req, res) {
+    try {
+      const baseUrl = this.target ?? `http://${req.headers.host ?? "localhost"}`;
+      const url = new URL(req.url ?? "/", baseUrl);
+      if (this.options?.debug) {
+        console.log(`[webapps-proxy] Forwarding to dev server: ${url.href}`);
+      }
+      const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : void 0;
+      const response = await fetch(url.href, {
+        method: req.method,
+        headers: getFilteredHeaders(req.headers),
+        body
+      });
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[webapps-proxy] Dev server request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward request to dev server");
     }
-    sendNoOrgError(res) {
-        res.writeHead(401, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
-            error: "NO_ORG_FOUND",
-            message: "No default Salesforce org found. Run 'sf org login web --set-default' to authenticate.",
-        }));
+  }
+  handleRedirect(res, location, statusCode) {
+    res.writeHead(statusCode, { Location: location });
+    res.end();
+  }
+  handleHealthCheck(res) {
+    const response = {
+      proxyName: "@salesforce/webapp-experimental",
+      proxyVersion: version,
+      port: this.target ? new URL(this.target).port : void 0,
+      org: this.orgInfo?.orgAlias ?? this.orgInfo?.username,
+      apiVersion: this.orgInfo?.apiVersion,
+      webappName: this.manifest.name,
+      webappFolderPath: this.basePath,
+      uptime: Date.now() - this.startTime,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      debugMode: this.options?.debug ?? false
+    };
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      [WEBAPP_PROXY_HEADER]: "true"
+    });
+    res.end(JSON.stringify(response, null, 2));
+  }
+  sendNoOrgError(res) {
+    res.writeHead(401, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "NO_ORG_FOUND",
+        message: "No default Salesforce org found. Run 'sf org login web --set-default' to authenticate."
+      })
+    );
+  }
+  sendJson(res, statusCode, body) {
+    res.writeHead(statusCode, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+  }
+  sendAuthOrGatewayError(res, error, gatewayMessage) {
+    if (error instanceof AuthenticationError) {
+      this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+    } else {
+      this.sendJson(res, 502, {
+        error: "GATEWAY_ERROR",
+        message: gatewayMessage
+      });
     }
-    sendJson(res, statusCode, body) {
-        res.writeHead(statusCode, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(body));
+  }
+  async handleLightningOutFrontdoor(req, res, _url) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      if (req.method && req.method !== "GET") {
+        this.sendJson(res, 405, { error: "METHOD_NOT_ALLOWED", message: "Use GET" });
+        return;
+      }
+      const { rawInstanceUrl, accessToken, orgId } = this.orgInfo;
+      const frontdoorUrl = await this.fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken);
+      if (!frontdoorUrl) {
+        this.sendJson(res, 502, {
+          error: "FRONTDOOR_FAILED",
+          message: "No frontdoor URL returned from Salesforce"
+        });
+        return;
+      }
+      this.sendJson(res, 200, {
+        frontdoorUrl,
+        instanceUrl: rawInstanceUrl,
+        orgId
+      });
+    } catch (error) {
+      console.error("[webapps-proxy] Frontdoor request failed:", error);
+      this.sendJson(res, 502, {
+        error: "GATEWAY_ERROR",
+        message: "Failed to generate frontdoor URL"
+      });
     }
-    sendAuthOrGatewayError(res, error, gatewayMessage) {
-        if (error instanceof AuthenticationError) {
-            this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
-        }
-        else {
-            this.sendJson(res, 502, {
-                error: "GATEWAY_ERROR",
-                message: gatewayMessage,
-            });
+  }
+  async fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken) {
+    let baseUrl = rawInstanceUrl.replace(/\/$/, "");
+    let response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    if (response.status === 401 || response.status === 403) {
+      const updatedOrgInfo = await this.refreshToken();
+      if (!updatedOrgInfo) {
+        throw new AuthenticationError("Failed to refresh token");
+      }
+      baseUrl = updatedOrgInfo.rawInstanceUrl.replace(/\/$/, "");
+      response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${updatedOrgInfo.accessToken}`,
+          "Content-Type": "application/x-www-form-urlencoded"
         }
+      });
     }
-    async handleLightningOutFrontdoor(req, res, _url) {
-        try {
-            if (!this.orgInfo) {
-                this.sendNoOrgError(res);
-                return;
-            }
-            if (req.method && req.method !== "GET") {
-                this.sendJson(res, 405, { error: "METHOD_NOT_ALLOWED", message: "Use GET" });
-                return;
-            }
-            const { rawInstanceUrl, accessToken, orgId } = this.orgInfo;
-            const frontdoorUrl = await this.fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken);
-            if (!frontdoorUrl) {
-                this.sendJson(res, 502, {
-                    error: "FRONTDOOR_FAILED",
-                    message: "No frontdoor URL returned from Salesforce",
-                });
-                return;
-            }
-            this.sendJson(res, 200, {
-                frontdoorUrl,
-                instanceUrl: rawInstanceUrl,
-                orgId,
-            });
-        }
-        catch (error) {
-            console.error("[webapps-proxy] Frontdoor request failed:", error);
-            this.sendJson(res, 502, {
-                error: "GATEWAY_ERROR",
-                message: "Failed to generate frontdoor URL",
-            });
-        }
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Frontdoor exchange failed: ${response.status} ${errorBody}`);
     }
-    async fetchLightningOutFrontdoorUrl(rawInstanceUrl, accessToken) {
-        let baseUrl = rawInstanceUrl.replace(/\/$/, "");
-        let response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-        });
-        if (response.status === 401 || response.status === 403) {
-            const updatedOrgInfo = await this.refreshToken();
-            if (!updatedOrgInfo) {
-                throw new AuthenticationError("Failed to refresh token");
-            }
-            baseUrl = updatedOrgInfo.rawInstanceUrl.replace(/\/$/, "");
-            response = await fetch(`${baseUrl}${LIGHTNING_OUT_SINGLE_ACCESS_PATH}`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${updatedOrgInfo.accessToken}`,
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-            });
+    const data = await response.json();
+    return data.frontdoor_uri ?? null;
+  }
+  async handleSalesforceApi(req, res) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      let pathIndex = url.pathname.indexOf("/lwr/apex/v");
+      if (pathIndex === -1) {
+        pathIndex = url.pathname.indexOf("/services/data/v");
+      }
+      const apiPath = url.pathname.substring(pathIndex);
+      let targetUrl = `${this.orgInfo.instanceUrl}${apiPath}${url.search}`;
+      if (this.options?.debug) {
+        console.log(`[webapps-proxy] Forwarding to Salesforce: ${targetUrl}`);
+      }
+      const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : void 0;
+      let response = await fetch(targetUrl, {
+        method: req.method,
+        headers: {
+          ...getFilteredHeaders(req.headers),
+          Cookie: `sid=${this.orgInfo.accessToken}`,
+          Accept: req.headers.accept ?? "application/json",
+          // necessary for Apex requests, for which SessionUtil.validateSessionUsage won't accept OAuth token as `sid` cookie
+          Authorization: `Bearer ${this.orgInfo.accessToken}`
+        },
+        body
+      });
+      if (response.status === 401 || response.status === 403) {
+        console.warn(`[webapps-proxy] Received ${response.status}, refreshing token...`);
+        const updatedOrgInfo = await this.refreshToken();
+        if (updatedOrgInfo === void 0) {
+          console.error("[webapps-proxy] Failed to refresh token - authentication error");
+          this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+          return;
         }
-        if (!response.ok) {
-            const errorBody = await response.text();
-            throw new Error(`Frontdoor exchange failed: ${response.status} ${errorBody}`);
+        if (this.options?.debug) {
+          console.log("[webapps-proxy] Token refreshed, retrying request");
         }
-        const data = (await response.json());
-        return data.frontdoor_uri ?? null;
+        targetUrl = `${updatedOrgInfo.instanceUrl}${url.pathname}${url.search}`;
+        response = await fetch(targetUrl, {
+          method: req.method,
+          headers: {
+            ...getFilteredHeaders(req.headers),
+            Cookie: `sid=${updatedOrgInfo.accessToken}`,
+            Accept: req.headers.accept ?? "application/json"
+          },
+          body
+        });
+      }
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[webapps-proxy] Salesforce API request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward request to Salesforce");
     }
-    async handleSalesforceApi(req, res) {
-        try {
-            if (!this.orgInfo) {
-                this.sendNoOrgError(res);
-                return;
-            }
-            const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-            let pathIndex = url.pathname.indexOf("/lwr/apex/v");
-            if (pathIndex === -1) {
-                pathIndex = url.pathname.indexOf("/services/data/v");
-            }
-            const apiPath = url.pathname.substring(pathIndex);
-            let targetUrl = `${this.orgInfo.instanceUrl}${apiPath}${url.search}`;
-            if (this.options?.debug) {
-                console.log(`[webapps-proxy] Forwarding to Salesforce: ${targetUrl}`);
-            }
-            // Buffer the request body before sending. This allows us to retry requests
-            // with the same body in case of authentication failures (403).
-            // For GET/HEAD requests, body is undefined.
-            const body = req.method !== "GET" && req.method !== "HEAD" ? await getBody(req) : undefined;
-            let response = await fetch(targetUrl, {
-                method: req.method,
-                headers: {
-                    ...getFilteredHeaders(req.headers),
-                    Cookie: `sid=${this.orgInfo.accessToken}`,
-                    Accept: req.headers.accept ?? "application/json",
-                    // necessary for Apex requests, for which SessionUtil.validateSessionUsage won't accept OAuth token as `sid` cookie
-                    Authorization: `Bearer ${this.orgInfo.accessToken}`,
-                },
-                body: body,
-            });
-            if (response.status === 401 || response.status === 403) {
-                console.warn(`[webapps-proxy] Received ${response.status}, refreshing token...`);
-                const updatedOrgInfo = await this.refreshToken();
-                if (updatedOrgInfo === undefined) {
-                    console.error("[webapps-proxy] Failed to refresh token - authentication error");
-                    this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
-                    return;
-                }
-                if (this.options?.debug) {
-                    console.log("[webapps-proxy] Token refreshed, retrying request");
-                }
-                // Update target URL with refreshed org info (instance URL may have changed)
-                targetUrl = `${updatedOrgInfo.instanceUrl}${url.pathname}${url.search}`;
-                // Retry with the same buffered body
-                response = await fetch(targetUrl, {
-                    method: req.method,
-                    headers: {
-                        ...getFilteredHeaders(req.headers),
-                        Cookie: `sid=${updatedOrgInfo.accessToken}`,
-                        Accept: req.headers.accept ?? "application/json",
-                    },
-                    body: body,
-                });
-            }
-            await this.sendResponse(res, response);
-        }
-        catch (error) {
-            console.error("[webapps-proxy] Salesforce API request failed:", error);
-            this.sendAuthOrGatewayError(res, error, "Failed to forward request to Salesforce");
-        }
+  }
+  async refreshToken() {
+    if (!this.orgInfo) {
+      return void 0;
     }
-    async refreshToken() {
-        if (!this.orgInfo) {
-            return undefined;
-        }
-        // Use orgAlias if available, otherwise fall back to username
-        // This handles cases where orgInfo was created without an explicit alias
-        const refreshIdentifier = this.orgInfo.orgAlias || this.orgInfo.username;
-        if (!refreshIdentifier) {
-            throw new AuthenticationError("Cannot refresh token: no org alias or username available");
-        }
-        const updatedOrgInfo = await refreshOrgAuth(refreshIdentifier);
-        if (!updatedOrgInfo) {
-            return undefined;
-        }
-        this.orgInfo = updatedOrgInfo;
-        // Notify plugin of token refresh so it can sync its orgInfo
-        if (this.options?.onTokenRefresh) {
-            this.options.onTokenRefresh(updatedOrgInfo);
-        }
-        return updatedOrgInfo;
+    const refreshIdentifier = this.orgInfo.orgAlias || this.orgInfo.username;
+    if (!refreshIdentifier) {
+      throw new AuthenticationError("Cannot refresh token: no org alias or username available");
     }
-    async handleGraphQL(req, res) {
-        try {
-            if (!this.orgInfo) {
-                this.sendNoOrgError(res);
-                return;
-            }
-            const { rawInstanceUrl, apiVersion, accessToken } = this.orgInfo;
-            let targetUrl = `${rawInstanceUrl}/services/data/v${apiVersion}/graphql`;
-            if (this.options?.debug) {
-                console.log(`[webapps-proxy] Forwarding GraphQL to Salesforce: ${targetUrl}`);
-            }
-            // Buffer the request body before sending. This allows us to retry requests
-            // with the same body in case of authentication failures (401/403).
-            const body = await getBody(req);
-            const headers = {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                Authorization: `Bearer ${accessToken}`,
-                "X-Chatter-Entity-Encoding": "false",
-            };
-            let response = await fetch(targetUrl, {
-                method: "POST",
-                headers,
-                body: body,
-            });
-            if (response.status === 401 || response.status === 403) {
-                console.warn(`[webapps-proxy] Received ${response.status}, refreshing token...`);
-                const updatedOrgInfo = await this.refreshToken();
-                if (updatedOrgInfo !== undefined) {
-                    if (this.options?.debug) {
-                        console.log("[webapps-proxy] Token refreshed, retrying request");
-                    }
-                    const { rawInstanceUrl, apiVersion, accessToken } = updatedOrgInfo;
-                    targetUrl = `${rawInstanceUrl}/services/data/v${apiVersion}/graphql`;
-                    headers.Authorization = `Bearer ${accessToken}`;
-                    response = await fetch(targetUrl, {
-                        method: "POST",
-                        headers,
-                        body: body,
-                    });
-                }
-                else {
-                    console.error("[webapps-proxy] Failed to refresh token for GraphQL - authentication error");
-                    this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
-                    return;
-                }
-            }
-            await this.sendResponse(res, response);
-        }
-        catch (error) {
-            console.error("[webapps-proxy] GraphQL request failed:", error);
-            this.sendAuthOrGatewayError(res, error, "Failed to forward GraphQL request to Salesforce");
-        }
+    const updatedOrgInfo = await refreshOrgAuth(refreshIdentifier);
+    if (!updatedOrgInfo) {
+      return void 0;
     }
-    async sendResponse(res, response) {
-        const headers = {};
-        const skipHeaders = new Set(["content-encoding", "content-length", "transfer-encoding"]);
-        response.headers.forEach((value, key) => {
-            if (!skipHeaders.has(key.toLowerCase())) {
-                headers[key] = value;
-            }
-        });
-        // Check if response is HTML and should have script injected
-        const contentType = response.headers.get("content-type") || "";
-        const isHtml = contentType.includes("text/html");
-        if (isHtml && response.body) {
-            // Buffer the entire response body to inject script
-            const chunks = [];
-            const reader = response.body.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                chunks.push(value);
-            }
-            // Combine all chunks into a single buffer
-            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-            const buffer = new Uint8Array(totalLength);
-            let offset = 0;
-            for (const chunk of chunks) {
-                buffer.set(chunk, offset);
-                offset += chunk.length;
-            }
-            // Convert to string, inject script, and convert back
-            const html = new TextDecoder().decode(buffer);
-            const modifiedHtml = WebAppProxyHandler.injectLivePreviewScript(html);
-            // Update content-length header
-            const modifiedBuffer = new TextEncoder().encode(modifiedHtml);
-            headers["content-length"] = modifiedBuffer.length.toString();
-            res.writeHead(response.status, headers);
-            res.write(modifiedBuffer);
-        }
-        else {
-            // For non-HTML responses, stream as before
-            res.writeHead(response.status, headers);
-            if (response.body) {
-                const reader = response.body.getReader();
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    res.write(value);
-                }
-            }
-        }
-        res.end();
+    this.orgInfo = updatedOrgInfo;
+    if (this.options?.onTokenRefresh) {
+      this.options.onTokenRefresh(updatedOrgInfo);
     }
-    static injectLivePreviewScript(html) {
-        if (html.includes(LIVE_PREVIEW_SCRIPT_MARKER)) {
-            return html;
-        }
-        const scriptContent = getLivePreviewScriptContent();
-        const scriptTag = `<script ${LIVE_PREVIEW_SCRIPT_MARKER}>` + scriptContent + "<" + "/script>";
-        if (html.includes("</body>")) {
-            const lastBodyIndex = html.lastIndexOf("</body>");
-            return html.substring(0, lastBodyIndex) + scriptTag + html.substring(lastBodyIndex);
-        }
-        if (html.includes("</html>")) {
-            const lastHtmlIndex = html.lastIndexOf("</html>");
-            return html.substring(0, lastHtmlIndex) + scriptTag + html.substring(lastHtmlIndex);
+    return updatedOrgInfo;
+  }
+  async handleGraphQL(req, res) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const { rawInstanceUrl, apiVersion, accessToken } = this.orgInfo;
+      let targetUrl = `${rawInstanceUrl}/services/data/v${apiVersion}/graphql`;
+      if (this.options?.debug) {
+        console.log(`[webapps-proxy] Forwarding GraphQL to Salesforce: ${targetUrl}`);
+      }
+      const body = await getBody(req);
+      const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "X-Chatter-Entity-Encoding": "false"
+      };
+      let response = await fetch(targetUrl, {
+        method: "POST",
+        headers,
+        body
+      });
+      if (response.status === 401 || response.status === 403) {
+        console.warn(`[webapps-proxy] Received ${response.status}, refreshing token...`);
+        const updatedOrgInfo = await this.refreshToken();
+        if (updatedOrgInfo !== void 0) {
+          if (this.options?.debug) {
+            console.log("[webapps-proxy] Token refreshed, retrying request");
+          }
+          const { rawInstanceUrl: rawInstanceUrl2, apiVersion: apiVersion2, accessToken: accessToken2 } = updatedOrgInfo;
+          targetUrl = `${rawInstanceUrl2}/services/data/v${apiVersion2}/graphql`;
+          headers.Authorization = `Bearer ${accessToken2}`;
+          response = await fetch(targetUrl, {
+            method: "POST",
+            headers,
+            body
+          });
+        } else {
+          console.error(
+            "[webapps-proxy] Failed to refresh token for GraphQL - authentication error"
+          );
+          this.sendJson(res, 401, AUTH_FAILED_RESPONSE);
+          return;
         }
-        return html + scriptTag;
+      }
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[webapps-proxy] GraphQL request failed:", error);
+      this.sendAuthOrGatewayError(res, error, "Failed to forward GraphQL request to Salesforce");
     }
-    /**
-     * Proxy POST /chatter/handlers/file/body (XHR/file upload) to Salesforce.
-     * Uses rawInstanceUrl for Chatter API. Preserves multipart/form-data from XHR.
-     */
-    async handleFileUpload(req, res, url) {
-        try {
-            if (!this.orgInfo) {
-                this.sendNoOrgError(res);
-                return;
-            }
-            // Strip basePath when forwarding to Salesforce (Salesforce expects /chatter/handlers/file/body)
-            const pathForSalesforce = this.basePath && url.pathname.startsWith(this.basePath)
-                ? url.pathname.slice(this.basePath.length) || "/"
-                : url.pathname;
-            const uploadUrl = `${this.orgInfo.rawInstanceUrl}${pathForSalesforce}${url.search}`;
-            const body = await getBody(req);
-            if (!body?.length) {
-                res.writeHead(400, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({
-                    error: "BAD_REQUEST",
-                    message: "Request body is empty",
-                }));
-                return;
-            }
-            const contentType = req.headers["content-type"];
-            if (!contentType?.includes("multipart/form-data")) {
-                res.writeHead(400, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({
-                    error: "BAD_REQUEST",
-                    message: "Content-Type must be multipart/form-data",
-                }));
-                return;
-            }
-            const headers = {
-                "Content-Type": contentType,
-                "Content-Length": String(body.length),
-                Cookie: `sid=${this.orgInfo.accessToken}`,
-                Authorization: `Bearer ${this.orgInfo.accessToken}`,
-            };
-            const response = await fetch(uploadUrl, {
-                method: "POST",
-                headers,
-                body: new Uint8Array(body),
-            });
-            await this.sendResponse(res, response);
-        }
-        catch (error) {
-            console.error("[webapps-proxy] File upload proxy failed:", error);
-            res.writeHead(502, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                error: "GATEWAY_ERROR",
-                message: "Failed to forward file upload",
-            }));
+  }
+  async sendResponse(res, response) {
+    const headers = {};
+    const skipHeaders = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+    response.headers.forEach((value, key) => {
+      if (!skipHeaders.has(key.toLowerCase())) {
+        headers[key] = value;
+      }
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const isHtml = contentType.includes("text/html");
+    if (isHtml && response.body) {
+      const chunks = [];
+      const reader = response.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const buffer = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const html = new TextDecoder().decode(buffer);
+      const modifiedHtml = WebAppProxyHandler.injectLivePreviewScript(html);
+      const modifiedBuffer = new TextEncoder().encode(modifiedHtml);
+      headers["content-length"] = modifiedBuffer.length.toString();
+      res.writeHead(response.status, headers);
+      res.write(modifiedBuffer);
+    } else {
+      res.writeHead(response.status, headers);
+      if (response.body) {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
         }
+      }
+    }
+    res.end();
+  }
+  static injectLivePreviewScript(html) {
+    if (html.includes(LIVE_PREVIEW_SCRIPT_MARKER)) {
+      return html;
+    }
+    const scriptContent = getLivePreviewScriptContent();
+    const scriptTag = `<script ${LIVE_PREVIEW_SCRIPT_MARKER}>` + scriptContent + "<\/script>";
+    if (html.includes("</body>")) {
+      const lastBodyIndex = html.lastIndexOf("</body>");
+      return html.substring(0, lastBodyIndex) + scriptTag + html.substring(lastBodyIndex);
     }
+    if (html.includes("</html>")) {
+      const lastHtmlIndex = html.lastIndexOf("</html>");
+      return html.substring(0, lastHtmlIndex) + scriptTag + html.substring(lastHtmlIndex);
+    }
+    return html + scriptTag;
+  }
+  /**
+   * Proxy POST /chatter/handlers/file/body (XHR/file upload) to Salesforce.
+   * Uses rawInstanceUrl for Chatter API. Preserves multipart/form-data from XHR.
+   */
+  async handleFileUpload(req, res, url) {
+    try {
+      if (!this.orgInfo) {
+        this.sendNoOrgError(res);
+        return;
+      }
+      const pathForSalesforce = this.basePath && url.pathname.startsWith(this.basePath) ? url.pathname.slice(this.basePath.length) || "/" : url.pathname;
+      const uploadUrl = `${this.orgInfo.rawInstanceUrl}${pathForSalesforce}${url.search}`;
+      const body = await getBody(req);
+      if (!body?.length) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "BAD_REQUEST",
+            message: "Request body is empty"
+          })
+        );
+        return;
+      }
+      const contentType = req.headers["content-type"];
+      if (!contentType?.includes("multipart/form-data")) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "BAD_REQUEST",
+            message: "Content-Type must be multipart/form-data"
+          })
+        );
+        return;
+      }
+      const headers = {
+        "Content-Type": contentType,
+        "Content-Length": String(body.length),
+        Cookie: `sid=${this.orgInfo.accessToken}`,
+        Authorization: `Bearer ${this.orgInfo.accessToken}`
+      };
+      const response = await fetch(uploadUrl, {
+        method: "POST",
+        headers,
+        body: new Uint8Array(body)
+      });
+      await this.sendResponse(res, response);
+    } catch (error) {
+      console.error("[webapps-proxy] File upload proxy failed:", error);
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "GATEWAY_ERROR",
+          message: "Failed to forward file upload"
+        })
+      );
+    }
+  }
 }
-/**
- * Create proxy request handler
- *
- * @param manifest - WebApp manifest configuration
- * @param orgInfo - Salesforce org information
- * @param target - Target URL for dev server forwarding (optional)
- * @param basePath - Base path for routing (optional)
- * @param options - Proxy configuration options
- * @returns Async request handler function for Node.js HTTP server
- */
-export function createProxyHandler(manifest, orgInfo, target, basePath, options) {
-    const handler = new WebAppProxyHandler(manifest, orgInfo, target, basePath, options);
-    return (req, res, next) => handler.handle(req, res, next);
+function createProxyHandler(manifest, orgInfo, target, basePath, options) {
+  const handler = new WebAppProxyHandler(manifest, orgInfo, target, basePath, options);
+  return (req, res, next) => handler.handle(req, res, next);
 }
-/**
- * Inject Live Preview script into HTML content.
- * Used by the Vite plugin's transformIndexHtml hook and the standalone proxy's sendResponse.
- */
-export function injectLivePreviewScript(html) {
-    return WebAppProxyHandler.injectLivePreviewScript(html);
+function injectLivePreviewScript(html) {
+  return WebAppProxyHandler.injectLivePreviewScript(html);
 }
 function getFilteredHeaders(headers) {
-    const filtered = {};
-    const hopByHopHeaders = new Set([
-        "connection",
-        "keep-alive",
-        "proxy-authenticate",
-        "proxy-authorization",
-        "te",
-        "trailer",
-        "transfer-encoding",
-        "upgrade",
-    ]);
-    for (const [key, value] of Object.entries(headers)) {
-        if (!hopByHopHeaders.has(key.toLowerCase()) && value) {
-            filtered[key] = Array.isArray(value)
-                ? value.join(", ")
-                : typeof value === "string"
-                    ? value
-                    : String(value);
-        }
+  const filtered = {};
+  const hopByHopHeaders = /* @__PURE__ */ new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade"
+  ]);
+  for (const [key, value] of Object.entries(headers)) {
+    if (!hopByHopHeaders.has(key.toLowerCase()) && value) {
+      filtered[key] = Array.isArray(value) ? value.join(", ") : typeof value === "string" ? value : String(value);
     }
-    return filtered;
+  }
+  return filtered;
 }
 function getBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
-        req.on("end", () => resolve(Buffer.concat(chunks)));
-        req.on("error", reject);
-    });
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
 }
+export {
+  WEBAPP_HEALTH_CHECK_PARAM,
+  WEBAPP_PROXY_HEADER,
+  createProxyHandler,
+  injectLivePreviewScript
+};