@nocobase/server 2.3.0-beta.5 → 2.4.0-alpha.1

package/lib/gateway/index.d.ts

@@ -59,6 +59,7 @@ export declare class Gateway extends EventEmitter {
     private host;
     private socketPath;
     private v2IndexTemplateCache;
+    private settingsIndexTemplateCache;
     private terminating;
     private getOriginalRequestUrl;
     private proxyRequestToSubApp;
@@ -80,6 +81,18 @@ export declare class Gateway extends EventEmitter {
     responseErrorWithCode(code: any, res: any, options: any): void;
     private getV2PublicPath;
     private getAppPublicPath;
+    private getSettingsPublicPath;
+    private getPathWithinAppPublicPath;
+    private isSettingsRequest;
+    private isSettingsIndexRequest;
+    private isSettingsAssetsRequest;
+    private resolveLegacyV2SettingsRedirect;
+    private getPortalRootPublicPath;
+    private getPortalAppPublicPath;
+    private resolvePortalRootEntryRedirect;
+    private getPortalMatch;
+    private isPortalIndexRequest;
+    private getPortalDistRoot;
     private isV2Request;
     private isV2IndexRequest;
     private getV2RuntimeConfig;
@@ -87,6 +100,11 @@ export declare class Gateway extends EventEmitter {
     private getV2AssetPublicPath;
     private getV2IndexTemplate;
     private renderV2IndexHtml;
+    private getSettingsRuntimeConfig;
+    private getSettingsRuntimeConfigScript;
+    private getSettingsAssetPublicPath;
+    private getSettingsIndexTemplate;
+    private renderSettingsIndexHtml;
     requestHandler(req: IncomingMessage, res: ServerResponse): Promise<void>;
     getAppSelectorMiddlewares(): Toposort<AppSelectorMiddleware>;
     getRequestHandleAppName(req: IncomingMessage | IncomingRequest): Promise<string>;

package/lib/gateway/index.js

@@ -114,6 +114,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   host = "0.0.0.0";
   socketPath = getSocketPath();
   v2IndexTemplateCache = null;
+  settingsIndexTemplateCache = null;
   terminating = false;
   getOriginalRequestUrl(req) {
     return req.originalUrl || req.url;
@@ -156,6 +157,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   }, "onTerminate");
   constructor() {
     super();
+    (0, import_utils3.normalizeModernClientPrefix)(import_node_process.default.env.APP_MODERN_CLIENT_PREFIX);
     this.reset();
     import_node_process.default.once("SIGTERM", this.onTerminate);
     import_node_process.default.once("SIGINT", this.onTerminate);
@@ -188,19 +190,28 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     this.selectorMiddlewares = new import_utils.Toposort();
     this.addAppSelectorMiddleware(
       async (ctx, next) => {
-        var _a, _b;
+        var _a, _b, _c;
         const { req } = ctx;
         const parsedUrl = (0, import_url.parse)(req.url);
         const appName = (_a = import_qs.default.parse(parsedUrl.query)) == null ? void 0 : _a.__appName;
         const apiBasePath = normalizeBasePath(import_node_process.default.env.API_BASE_PATH || "/api");
         const appPathPrefix = `${apiBasePath}/__app/`;
+        const appPublicPath = (0, import_utils3.resolvePublicPath)(import_node_process.default.env.APP_PUBLIC_PATH || "/");
+        const portalAppsPathPrefix = `${appPublicPath.replace(/\/$/, "")}/${import_utils3.PORTAL_CLIENT_PREFIX}/apps/`;
         if (req.headers["x-app"]) {
           ctx.resolvedAppName = req.headers["x-app"];
         }
         if (appName) {
           ctx.resolvedAppName = appName;
         }
-        if ((_b = parsedUrl.pathname) == null ? void 0 : _b.startsWith(appPathPrefix)) {
+        if ((_b = parsedUrl.pathname) == null ? void 0 : _b.startsWith(portalAppsPathPrefix)) {
+          const restPath = parsedUrl.pathname.slice(portalAppsPathPrefix.length);
+          const [pathAppName] = restPath.split("/");
+          if (pathAppName) {
+            ctx.resolvedAppName = (0, import_utils3.normalizePortalAppName)(pathAppName);
+          }
+        }
+        if ((_c = parsedUrl.pathname) == null ? void 0 : _c.startsWith(appPathPrefix)) {
           const restPath = parsedUrl.pathname.slice(appPathPrefix.length);
           const [pathAppName, ...segments] = restPath.split("/");
           if (pathAppName) {
@@ -292,6 +303,156 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   getAppPublicPath() {
     return (0, import_utils3.resolvePublicPath)(import_node_process.default.env.APP_PUBLIC_PATH || "/");
   }
+  getSettingsPublicPath() {
+    return (0, import_utils3.resolveSettingsPublicPath)(import_node_process.default.env.APP_PUBLIC_PATH || "/");
+  }
+  getPathWithinAppPublicPath(pathname) {
+    const appPublicPath = this.getAppPublicPath();
+    if (appPublicPath === "/") {
+      return pathname;
+    }
+    const appPublicPathWithoutSlash = appPublicPath.slice(0, -1);
+    if (pathname === appPublicPathWithoutSlash) {
+      return "/";
+    }
+    if (!pathname.startsWith(appPublicPath)) {
+      return null;
+    }
+    return pathname.slice(appPublicPath.length - 1);
+  }
+  isSettingsRequest(pathname) {
+    const appPath = this.getPathWithinAppPublicPath(pathname);
+    if (!appPath) {
+      return false;
+    }
+    return /^\/settings(?:\/|$)/.test(appPath);
+  }
+  isSettingsIndexRequest(pathname) {
+    if (!this.isSettingsRequest(pathname)) {
+      return false;
+    }
+    if (pathname.endsWith("/index.html")) {
+      return true;
+    }
+    return !(0, import_path.extname)(pathname);
+  }
+  isSettingsAssetsRequest(pathname) {
+    const appPath = this.getPathWithinAppPublicPath(pathname);
+    return appPath ? /^\/settings\/assets\//.test(appPath) : false;
+  }
+  resolveLegacyV2SettingsRedirect(pathname) {
+    const appPath = this.getPathWithinAppPublicPath(pathname);
+    if (!appPath) {
+      return null;
+    }
+    const modernPrefix = (0, import_utils3.normalizeModernClientPrefix)(import_node_process.default.env.APP_MODERN_CLIENT_PREFIX);
+    const escapedModernPrefix = modernPrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = appPath.match(new RegExp(`^/${escapedModernPrefix}((?:/(?:apps|_app)/[^/]+)?)(/admin(?:/.*)?)$`));
+    if (!match) {
+      return null;
+    }
+    const appScope = match[1] || "";
+    const legacyPath = match[2];
+    const mappings = [
+      {
+        from: "/admin/settings/mail/oauth2",
+        to: "/admin/settings/mail/oauth2"
+      },
+      {
+        from: "/admin/workflow/executions",
+        to: "/settings/workflow/executions"
+      },
+      {
+        from: "/admin/workflow/workflows",
+        to: "/settings/workflow/workflows"
+      },
+      {
+        from: "/admin/settings",
+        to: "/settings"
+      }
+    ];
+    for (const { from, to } of mappings) {
+      if (legacyPath !== from && !legacyPath.startsWith(`${from}/`)) {
+        continue;
+      }
+      const appPublicPath = this.getAppPublicPath().replace(/\/$/, "");
+      const targetPath = from === "/admin/settings/mail/oauth2" ? `${appScope}${to}` : appScope ? `/settings${appScope}${to.replace(/^\/settings(?=\/|$)/, "")}` : to;
+      return `${appPublicPath}${targetPath}${legacyPath.slice(from.length)}`;
+    }
+    return null;
+  }
+  getPortalRootPublicPath() {
+    return `${this.getAppPublicPath().replace(/\/$/, "")}/${import_utils3.PORTAL_CLIENT_PREFIX}/`;
+  }
+  getPortalAppPublicPath(appName) {
+    if (appName === import_utils3.DEFAULT_PORTAL_APP_NAME) {
+      return this.getPortalRootPublicPath();
+    }
+    return `${this.getPortalRootPublicPath()}apps/${(0, import_utils3.normalizePortalAppName)(appName)}/`;
+  }
+  resolvePortalRootEntryRedirect(pathname) {
+    const portalRootPublicPath = this.getPortalRootPublicPath();
+    const v2PublicPath = this.getV2PublicPath();
+    if (v2PublicPath === portalRootPublicPath) {
+      return null;
+    }
+    if (pathname === portalRootPublicPath || pathname === portalRootPublicPath.slice(0, -1)) {
+      return v2PublicPath;
+    }
+    const portalAppsPublicPath = `${portalRootPublicPath}apps/`;
+    if (!pathname.startsWith(portalAppsPublicPath)) {
+      return null;
+    }
+    const match = /^([A-Za-z0-9_-]+)\/?$/.exec(pathname.slice(portalAppsPublicPath.length));
+    return match ? `${v2PublicPath}apps/${match[1]}/` : null;
+  }
+  getPortalMatch(pathname) {
+    const portalRootPublicPath = this.getPortalRootPublicPath();
+    if (!pathname.startsWith(portalRootPublicPath)) {
+      return null;
+    }
+    let appName = import_utils3.DEFAULT_PORTAL_APP_NAME;
+    let publicRoot = portalRootPublicPath;
+    let restPath = pathname.slice(portalRootPublicPath.length).replace(/^\/+/, "");
+    const [firstSegment, secondSegment, ...remainingSegments] = restPath.split("/");
+    if (firstSegment === "apps") {
+      if (!secondSegment || !/^[A-Za-z0-9_-]+$/.test(secondSegment)) {
+        return null;
+      }
+      appName = (0, import_utils3.normalizePortalAppName)(secondSegment);
+      publicRoot = this.getPortalAppPublicPath(appName);
+      if (!pathname.startsWith(publicRoot)) {
+        return null;
+      }
+      restPath = remainingSegments.join("/").replace(/^\/+/, "");
+    }
+    const [portalName] = restPath.split("/");
+    if (!portalName || !/^[A-Za-z0-9_-]+$/.test(portalName)) {
+      return null;
+    }
+    return {
+      appName,
+      portalName,
+      publicPath: `${publicRoot}${portalName}/`
+    };
+  }
+  isPortalIndexRequest(pathname, portalPublicPath) {
+    if (pathname === portalPublicPath || pathname === portalPublicPath.slice(0, -1) || pathname === `${portalPublicPath}index.html`) {
+      return true;
+    }
+    return !(0, import_path.extname)(pathname);
+  }
+  getPortalDistRoot(portalMatch) {
+    const scopedRoot = (0, import_utils.storagePathJoin)("portals", portalMatch.appName, portalMatch.portalName, "dist");
+    if (portalMatch.appName !== import_utils3.DEFAULT_PORTAL_APP_NAME) {
+      return scopedRoot;
+    }
+    const legacyRoot = (0, import_utils.storagePathJoin)("portals", portalMatch.portalName, "dist");
+    if (!import_fs.default.existsSync((0, import_path.resolve)(scopedRoot, "index.html")) && import_fs.default.existsSync((0, import_path.resolve)(legacyRoot, "index.html"))) {
+      return legacyRoot;
+    }
+    return scopedRoot;
+  }
   isV2Request(pathname) {
     const v2PublicPath = this.getV2PublicPath();
     return pathname === v2PublicPath.slice(0, -1) || pathname.startsWith(v2PublicPath);
@@ -358,6 +519,57 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     const html = (0, import_utils3.rewriteV2AssetPublicPath)(template, this.getV2AssetPublicPath());
     return (0, import_utils3.injectRuntimeScript)(html, this.getV2RuntimeConfigScript());
   }
+  getSettingsRuntimeConfig() {
+    return {
+      __nocobase_public_path__: this.getAppPublicPath(),
+      __nocobase_modern_client_prefix__: (0, import_utils3.normalizeModernClientPrefix)(import_node_process.default.env.APP_MODERN_CLIENT_PREFIX),
+      __webpack_public_path__: import_node_process.default.env.CDN_BASE_URL ? `${import_node_process.default.env.CDN_BASE_URL.replace(/\/+$/, "")}/` : "",
+      __nocobase_api_base_url__: import_node_process.default.env.API_BASE_URL || import_node_process.default.env.API_BASE_PATH,
+      __nocobase_api_client_storage_prefix__: import_node_process.default.env.API_CLIENT_STORAGE_PREFIX,
+      __nocobase_api_client_storage_type__: import_node_process.default.env.API_CLIENT_STORAGE_TYPE,
+      __nocobase_api_client_share_token__: import_node_process.default.env.API_CLIENT_SHARE_TOKEN === "true",
+      __nocobase_ws_url__: import_node_process.default.env.WEBSOCKET_URL || "",
+      __nocobase_ws_path__: import_node_process.default.env.WS_PATH,
+      __nocobase_app_dev__: import_node_process.default.env.NOCOBASE_APP_DEV === "true",
+      __esm_cdn_base_url__: import_node_process.default.env.ESM_CDN_BASE_URL || "https://esm.sh",
+      __esm_cdn_suffix__: import_node_process.default.env.ESM_CDN_SUFFIX || ""
+    };
+  }
+  getSettingsRuntimeConfigScript() {
+    const scriptContent = Object.entries(this.getSettingsRuntimeConfig()).map(([key, value]) => `window['${key}'] = ${JSON.stringify(value)};`).join("\n");
+    return `<script>${scriptContent}</script>`;
+  }
+  getSettingsAssetPublicPath() {
+    if (import_node_process.default.env.CDN_BASE_URL) {
+      return `${import_node_process.default.env.CDN_BASE_URL.replace(/\/+$/, "")}/${import_utils3.SETTINGS_CLIENT_DIST_DIR}/`;
+    }
+    return this.getSettingsPublicPath();
+  }
+  getSettingsIndexTemplate() {
+    const file = `${import_node_process.default.env.APP_PACKAGE_ROOT}/dist/client/${import_utils3.SETTINGS_CLIENT_DIST_DIR}/index.html`;
+    if (!import_fs.default.existsSync(file)) {
+      return null;
+    }
+    const stat = import_fs.default.statSync(file);
+    if (this.settingsIndexTemplateCache && this.settingsIndexTemplateCache.file === file && this.settingsIndexTemplateCache.mtimeMs === stat.mtimeMs) {
+      return this.settingsIndexTemplateCache.html;
+    }
+    const html = import_fs.default.readFileSync(file, "utf-8");
+    this.settingsIndexTemplateCache = {
+      file,
+      mtimeMs: stat.mtimeMs,
+      html
+    };
+    return html;
+  }
+  renderSettingsIndexHtml() {
+    const template = this.getSettingsIndexTemplate();
+    if (!template) {
+      return null;
+    }
+    const html = (0, import_utils3.rewriteSettingsAssetPublicPath)(template, this.getSettingsAssetPublicPath());
+    return (0, import_utils3.injectRuntimeScript)(html, this.getSettingsRuntimeConfigScript());
+  }
   async requestHandler(req, res) {
     const { pathname, search } = (0, import_url.parse)(req.url);
     const { PLUGIN_STATICS_PATH } = import_node_process.default.env;
@@ -373,6 +585,20 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       res.end();
       return;
     }
+    const settingsRedirect = this.resolveLegacyV2SettingsRedirect(pathname);
+    if (settingsRedirect) {
+      res.statusCode = 302;
+      res.setHeader("Location", `${settingsRedirect}${search || ""}`);
+      res.end();
+      return;
+    }
+    const portalRootEntryRedirect = this.resolvePortalRootEntryRedirect(pathname);
+    if (portalRootEntryRedirect) {
+      res.statusCode = 302;
+      res.setHeader("Location", `${portalRootEntryRedirect}${search || ""}`);
+      res.end();
+      return;
+    }
     const supervisor = import_app_supervisor.AppSupervisor.getInstance();
     let handleApp = "main";
     try {
@@ -440,6 +666,70 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     }
     const isFilesRequest = Boolean(getFileAccessRestPath(pathname, APP_PUBLIC_PATH));
     if (!pathname.startsWith(import_node_process.default.env.API_BASE_PATH) && !isFilesRequest) {
+      if (this.isSettingsRequest(pathname)) {
+        if (handleApp !== "main") {
+          const isProxy = await this.proxyRequestToSubApp(supervisor, handleApp, req, res);
+          if (isProxy) {
+            return;
+          }
+        }
+        if (this.isSettingsIndexRequest(pathname)) {
+          const settingsHtml = this.renderSettingsIndexHtml();
+          if (settingsHtml) {
+            res.setHeader("Cache-Control", "no-store");
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.end(settingsHtml);
+            return;
+          }
+        }
+        if (this.isSettingsAssetsRequest(pathname)) {
+          res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+        }
+        req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
+        await compress(req, res);
+        return (0, import_serve_handler.default)(req, res, {
+          public: `${import_node_process.default.env.APP_PACKAGE_ROOT}/dist/client`
+        });
+      }
+      const portalMatch = this.getPortalMatch(pathname);
+      if (portalMatch) {
+        if (handleApp !== "main" && handleApp !== portalMatch.appName) {
+          const isProxy = await this.proxyRequestToSubApp(supervisor, handleApp, req, res);
+          if (isProxy) {
+            return;
+          }
+        }
+        const portalDistRoot = this.getPortalDistRoot(portalMatch);
+        const portalIndex = (0, import_path.resolve)(portalDistRoot, "index.html");
+        if (!import_fs.default.existsSync(portalIndex)) {
+          res.statusCode = 404;
+          res.end();
+          return;
+        }
+        if (!pathname.startsWith(portalMatch.publicPath)) {
+          res.statusCode = 302;
+          res.setHeader("Location", `${portalMatch.publicPath}${search || ""}`);
+          res.end();
+          return;
+        }
+        if (this.isPortalIndexRequest(pathname, portalMatch.publicPath)) {
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+          res.end(import_fs.default.readFileSync(portalIndex, "utf-8"));
+          return;
+        }
+        req.url = req.url.substring(portalMatch.publicPath.length - 1);
+        await compress(req, res);
+        return (0, import_serve_handler.default)(req, res, {
+          public: portalDistRoot,
+          directoryListing: false
+        });
+      }
+      const portalRootPublicPath = this.getPortalRootPublicPath();
+      if (pathname === portalRootPublicPath.slice(0, -1) || pathname.startsWith(portalRootPublicPath)) {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
       if (this.isV2Request(pathname)) {
         if (handleApp !== "main") {
           const isProxy = await this.proxyRequestToSubApp(supervisor, handleApp, req, res);

package/lib/gateway/utils.d.ts

@@ -10,10 +10,19 @@
 import { IncomingMessage } from 'http';
 import { IncomingRequest } from '.';
 export declare const MODERN_CLIENT_DIST_DIR = "v";
+export declare const SETTINGS_CLIENT_DIST_DIR = "settings";
+export declare const PORTAL_CLIENT_PREFIX = "x";
+export declare const DEFAULT_PORTAL_APP_NAME = "main";
+export declare const DEFAULT_PORTAL_NAME = "admin";
 export declare function resolvePublicPath(appPublicPath?: string): string;
 export declare function normalizeModernClientPrefix(value?: string): string;
 export declare function resolveV2PublicPath(appPublicPath?: string): string;
+export declare function resolveSettingsPublicPath(appPublicPath?: string): string;
+export declare function normalizePortalName(value?: string): string;
+export declare function normalizePortalAppName(value?: string): string;
+export declare function resolvePortalPublicPath(portalName: string, appPublicPath?: string): string;
 export declare function rewriteV2AssetPublicPath(html: string, assetPublicPath: string): string;
+export declare function rewriteSettingsAssetPublicPath(html: string, assetPublicPath: string): string;
 export declare function injectRuntimeScript(html: string, runtimeScript: string): string;
 export declare function getHost(req: IncomingMessage | IncomingRequest): any;
 export declare function getHostname(req: IncomingMessage | IncomingRequest): any;

package/lib/gateway/utils.js

@@ -27,17 +27,30 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  DEFAULT_PORTAL_APP_NAME: () => DEFAULT_PORTAL_APP_NAME,
+  DEFAULT_PORTAL_NAME: () => DEFAULT_PORTAL_NAME,
   MODERN_CLIENT_DIST_DIR: () => MODERN_CLIENT_DIST_DIR,
+  PORTAL_CLIENT_PREFIX: () => PORTAL_CLIENT_PREFIX,
+  SETTINGS_CLIENT_DIST_DIR: () => SETTINGS_CLIENT_DIST_DIR,
   getHost: () => getHost,
   getHostname: () => getHostname,
   injectRuntimeScript: () => injectRuntimeScript,
   normalizeModernClientPrefix: () => normalizeModernClientPrefix,
+  normalizePortalAppName: () => normalizePortalAppName,
+  normalizePortalName: () => normalizePortalName,
+  resolvePortalPublicPath: () => resolvePortalPublicPath,
   resolvePublicPath: () => resolvePublicPath,
+  resolveSettingsPublicPath: () => resolveSettingsPublicPath,
   resolveV2PublicPath: () => resolveV2PublicPath,
+  rewriteSettingsAssetPublicPath: () => rewriteSettingsAssetPublicPath,
   rewriteV2AssetPublicPath: () => rewriteV2AssetPublicPath
 });
 module.exports = __toCommonJS(utils_exports);
 const MODERN_CLIENT_DIST_DIR = "v";
+const SETTINGS_CLIENT_DIST_DIR = "settings";
+const PORTAL_CLIENT_PREFIX = "x";
+const DEFAULT_PORTAL_APP_NAME = "main";
+const DEFAULT_PORTAL_NAME = "admin";
 function resolvePublicPath(appPublicPath = "/") {
   const normalized = String(appPublicPath || "/").trim() || "/";
   const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
@@ -46,7 +59,11 @@ function resolvePublicPath(appPublicPath = "/") {
 __name(resolvePublicPath, "resolvePublicPath");
 function normalizeModernClientPrefix(value) {
   const segment = String(value || "").trim().replace(/^\/+|\/+$/g, "");
-  return segment || MODERN_CLIENT_DIST_DIR;
+  const normalized = segment || MODERN_CLIENT_DIST_DIR;
+  if (normalized === SETTINGS_CLIENT_DIST_DIR) {
+    throw new Error('APP_MODERN_CLIENT_PREFIX "settings" is reserved for the standalone Settings application.');
+  }
+  return normalized;
 }
 __name(normalizeModernClientPrefix, "normalizeModernClientPrefix");
 function resolveV2PublicPath(appPublicPath = "/") {
@@ -55,6 +72,26 @@ function resolveV2PublicPath(appPublicPath = "/") {
   return `${publicPath.replace(/\/$/, "")}/${prefix}/`;
 }
 __name(resolveV2PublicPath, "resolveV2PublicPath");
+function resolveSettingsPublicPath(appPublicPath = "/") {
+  const publicPath = resolvePublicPath(appPublicPath);
+  return `${publicPath.replace(/\/$/, "")}/${SETTINGS_CLIENT_DIST_DIR}/`;
+}
+__name(resolveSettingsPublicPath, "resolveSettingsPublicPath");
+function normalizePortalName(value) {
+  const segment = String(value || "").trim().replace(/^\/+|\/+$/g, "");
+  return segment || DEFAULT_PORTAL_NAME;
+}
+__name(normalizePortalName, "normalizePortalName");
+function normalizePortalAppName(value) {
+  const segment = String(value || "").trim().replace(/^\/+|\/+$/g, "");
+  return segment || DEFAULT_PORTAL_APP_NAME;
+}
+__name(normalizePortalAppName, "normalizePortalAppName");
+function resolvePortalPublicPath(portalName, appPublicPath = "/") {
+  const publicPath = resolvePublicPath(appPublicPath);
+  return `${publicPath.replace(/\/$/, "")}/${PORTAL_CLIENT_PREFIX}/${normalizePortalName(portalName)}/`;
+}
+__name(resolvePortalPublicPath, "resolvePortalPublicPath");
 function ensureTrailingSlash(value) {
   return value.endsWith("/") ? value : `${value}/`;
 }
@@ -69,6 +106,16 @@ function rewriteV2AssetPublicPath(html, assetPublicPath) {
   return html.replace(sentinelPattern, `$1${normalizedAssetPublicPath}`);
 }
 __name(rewriteV2AssetPublicPath, "rewriteV2AssetPublicPath");
+function rewriteSettingsAssetPublicPath(html, assetPublicPath) {
+  const normalizedAssetPublicPath = ensureTrailingSlash(assetPublicPath);
+  const sentinel = `/${SETTINGS_CLIENT_DIST_DIR}/`;
+  if (normalizedAssetPublicPath === sentinel) {
+    return html;
+  }
+  const sentinelPattern = new RegExp(`((?:src|href)=["'])${sentinel.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g");
+  return html.replace(sentinelPattern, `$1${normalizedAssetPublicPath}`);
+}
+__name(rewriteSettingsAssetPublicPath, "rewriteSettingsAssetPublicPath");
 function injectRuntimeScript(html, runtimeScript) {
   const browserCheckerScriptMatch = html.match(/<script\b[^>]*browser-checker\.js[^>]*><\/script>/i);
   if (browserCheckerScriptMatch == null ? void 0 : browserCheckerScriptMatch[0]) {
@@ -117,12 +164,21 @@ function getHostname(req) {
 __name(getHostname, "getHostname");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_PORTAL_APP_NAME,
+  DEFAULT_PORTAL_NAME,
   MODERN_CLIENT_DIST_DIR,
+  PORTAL_CLIENT_PREFIX,
+  SETTINGS_CLIENT_DIST_DIR,
   getHost,
   getHostname,
   injectRuntimeScript,
   normalizeModernClientPrefix,
+  normalizePortalAppName,
+  normalizePortalName,
+  resolvePortalPublicPath,
   resolvePublicPath,
+  resolveSettingsPublicPath,
   resolveV2PublicPath,
+  rewriteSettingsAssetPublicPath,
   rewriteV2AssetPublicPath
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/server",
-  "version": "2.3.0-beta.5",
+  "version": "2.4.0-alpha.1",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
@@ -10,21 +10,21 @@
     "@koa/cors": "^5.0.0",
     "@koa/multer": "^3.1.0",
     "@koa/router": "^13.1.0",
-    "@nocobase/acl": "2.3.0-beta.5",
-    "@nocobase/actions": "2.3.0-beta.5",
-    "@nocobase/ai": "2.3.0-beta.5",
-    "@nocobase/auth": "2.3.0-beta.5",
-    "@nocobase/cache": "2.3.0-beta.5",
-    "@nocobase/data-source-manager": "2.3.0-beta.5",
-    "@nocobase/database": "2.3.0-beta.5",
-    "@nocobase/evaluators": "2.3.0-beta.5",
-    "@nocobase/lock-manager": "2.3.0-beta.5",
-    "@nocobase/logger": "2.3.0-beta.5",
-    "@nocobase/resourcer": "2.3.0-beta.5",
-    "@nocobase/sdk": "2.3.0-beta.5",
-    "@nocobase/snowflake-id": "2.3.0-beta.5",
-    "@nocobase/telemetry": "2.3.0-beta.5",
-    "@nocobase/utils": "2.3.0-beta.5",
+    "@nocobase/acl": "2.4.0-alpha.1",
+    "@nocobase/actions": "2.4.0-alpha.1",
+    "@nocobase/ai": "2.4.0-alpha.1",
+    "@nocobase/auth": "2.4.0-alpha.1",
+    "@nocobase/cache": "2.4.0-alpha.1",
+    "@nocobase/data-source-manager": "2.4.0-alpha.1",
+    "@nocobase/database": "2.4.0-alpha.1",
+    "@nocobase/evaluators": "2.4.0-alpha.1",
+    "@nocobase/lock-manager": "2.4.0-alpha.1",
+    "@nocobase/logger": "2.4.0-alpha.1",
+    "@nocobase/resourcer": "2.4.0-alpha.1",
+    "@nocobase/sdk": "2.4.0-alpha.1",
+    "@nocobase/snowflake-id": "2.4.0-alpha.1",
+    "@nocobase/telemetry": "2.4.0-alpha.1",
+    "@nocobase/utils": "2.4.0-alpha.1",
     "@types/decompress": "4.2.7",
     "@types/ini": "^1.3.31",
     "@types/koa-send": "^4.1.3",
@@ -61,5 +61,5 @@
     "@types/serve-handler": "^6.1.1",
     "@types/ws": "^8.5.5"
   },
-  "gitHead": "7047516aba0d14965ddf457b64587103a871b923"
+  "gitHead": "82ecd3aed067e4cc98c32e7a0039b6e55cee76a7"
 }