everything-dev 1.12.4 → 1.13.1

package/src/config.ts

@@ -1,12 +1,30 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { fetchBosConfigFromFastKv } from "./fastkv";
+import { fetchBosConfigFromFastKv, fetchPluginFromRegistry, parsePluginBosUrl } from "./fastkv";
+import {
+  type BosEnv,
+  isPlainObject,
+  mergeBosConfigWithExtends,
+  type ResolvedConfigMeta,
+  rebuildOrderedConfig,
+  resolveExtendsRef,
+} from "./merge";
 import { getNetworkIdForAccount } from "./network";
-import type { BosConfig, BosConfigInput, RuntimeConfig, RuntimePluginConfig } from "./types";
+import type {
+  BosConfig,
+  BosConfigInput,
+  BosPluginRef,
+  ExtendsConfig,
+  PluginEntryValue,
+  RuntimeConfig,
+  RuntimePluginConfig,
+  SharedDepConfig,
+} from "./types";
 import { BosConfigSchema } from "./types";
 
 const LOCAL_PREFIX = "local:";
 const DEFAULT_HOST_PORT = 3000;
+const RESOLVED_CONFIG_FILENAME = "bos.resolved-config.json";
 
 interface RuntimeTarget {
   source: "local" | "remote";
@@ -59,7 +77,7 @@ export interface ConfigResult {
 export async function loadConfig(options?: {
   cwd?: string;
   path?: string;
-  env?: "development" | "production";
+  env?: BosEnv;
 }): Promise<ConfigResult | null> {
   const configPath = options?.path ?? findConfigPath(options?.cwd);
   if (!configPath) {
@@ -68,21 +86,25 @@ export async function loadConfig(options?: {
   }
 
   const baseDir = dirname(configPath);
+  const env = options?.env ?? "development";
+  const runtimeEnv: BosEnv = env === "staging" ? "production" : env;
 
   try {
     const extendedChain: string[] = [];
-    const parsed = await resolveConfigWithExtends(configPath, baseDir, new Set(), extendedChain);
+    const parsed = await resolveConfigWithExtends(
+      configPath,
+      baseDir,
+      new Set(),
+      extendedChain,
+      env,
+    );
     const config = BosConfigSchema.parse(parsed);
 
     cachedConfig = config;
     projectRoot = baseDir;
 
-    const pluginRuntime = await resolveRuntimePlugins(
-      config.plugins ?? {},
-      baseDir,
-      options?.env ?? "development",
-    );
-    const runtime = buildRuntimeConfig(config, baseDir, options?.env ?? "development", {
+    const pluginRuntime = await resolveRuntimePlugins(config.plugins ?? {}, baseDir, runtimeEnv);
+    const runtime = buildRuntimeConfig(config, baseDir, runtimeEnv, {
       plugins: pluginRuntime,
     });
 
@@ -103,7 +125,7 @@ export async function loadConfig(options?: {
 export async function loadBosConfig(options?: {
   cwd?: string;
   path?: string;
-  env?: "development" | "production";
+  env?: BosEnv;
 }): Promise<RuntimeConfig> {
   const result = await loadConfig(options);
   if (!result) {
@@ -116,12 +138,84 @@ export async function loadBosConfig(options?: {
 export async function buildRuntimePluginsForConfig(
   config: BosConfig,
   baseDir: string,
-  env: "development" | "production",
+  env: BosEnv,
 ): Promise<Record<string, RuntimePluginConfig> | undefined> {
   const plugins = await resolveRuntimePlugins(config.plugins ?? {}, baseDir, env);
   return Object.keys(plugins).length > 0 ? plugins : undefined;
 }
 
+export function getResolvedConfigPath(configDir: string): string {
+  return join(configDir, ".bos", RESOLVED_CONFIG_FILENAME);
+}
+
+export function loadResolvedConfig(configDir: string): BosConfig | null {
+  const resolvedPath = getResolvedConfigPath(configDir);
+  if (!existsSync(resolvedPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+    if (!isPlainObject(raw)) return null;
+    const { _resolved, ...configData } = raw;
+    return BosConfigSchema.parse(configData);
+  } catch {
+    return null;
+  }
+}
+
+export function writeResolvedConfig(
+  configDir: string,
+  config: BosConfig,
+  env: BosEnv,
+  extendsChain?: string[],
+  source?: string,
+): void {
+  const resolvedPath = getResolvedConfigPath(configDir);
+  const resolvedDir = dirname(resolvedPath);
+  if (!existsSync(resolvedDir)) {
+    mkdirSync(resolvedDir, { recursive: true });
+  }
+
+  const ordered = rebuildOrderedConfig(config);
+  const meta: ResolvedConfigMeta = {
+    env,
+    resolvedAt: new Date().toISOString(),
+    extendsChain: extendsChain ?? [],
+    ...(source ? { source } : {}),
+  };
+  const output = {
+    _resolved: meta,
+    ...ordered,
+  };
+
+  const content = `${JSON.stringify(output, null, 2)}\n`;
+  try {
+    if (readFileSync(resolvedPath, "utf-8") === content) return;
+  } catch {
+    // file doesn't exist yet
+  }
+  writeFileSync(resolvedPath, content);
+}
+
+export function resolveBosConfigPath(configDir: string): string {
+  const resolvedPath = getResolvedConfigPath(configDir);
+  if (existsSync(resolvedPath)) return resolvedPath;
+  return join(configDir, "bos.config.json");
+}
+
+export function readBosConfigForBuild(configDir: string): Record<string, unknown> {
+  const resolvedPath = getResolvedConfigPath(configDir);
+  if (existsSync(resolvedPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+      if (isPlainObject(raw)) {
+        const { _resolved, ...configData } = raw;
+        return configData as Record<string, unknown>;
+      }
+    } catch {}
+  }
+  const bosConfigPath = join(configDir, "bos.config.json");
+  return JSON.parse(readFileSync(bosConfigPath, "utf-8")) as Record<string, unknown>;
+}
+
 function resolveDevelopmentTarget(
   development: string | undefined,
   production: string | undefined,
@@ -150,7 +244,7 @@ export interface BuildRuntimeConfigOptions {
 export function buildRuntimeConfig(
   config: BosConfig,
   baseDir: string,
-  env: "development" | "production",
+  env: BosEnv,
   options?: BuildRuntimeConfigOptions,
 ): RuntimeConfig {
   const uiConfig = config.app.ui;
@@ -196,7 +290,10 @@ export function buildRuntimeConfig(
         )
       : resolveRuntimeTarget(hostConfig.production, baseDir, "remote");
 
-  const hostListeningUrl = resolveDevelopmentHostUrl(hostConfig.development);
+  const hostListeningUrl =
+    env === "development"
+      ? resolveDevelopmentHostUrl(hostConfig.development)
+      : `http://localhost:${hostRuntime.port ?? DEFAULT_HOST_PORT}`;
 
   const hostIsRemote = hostRuntime.source === "remote";
   const uiIsRemote = uiRuntime.source === "remote";
@@ -243,20 +340,26 @@ export function buildRuntimeConfig(
       secrets: apiConfig.secrets,
       integrity: apiIsRemote ? apiConfig.integrity : undefined,
     },
-    auth: authConfig
-      ? {
-          name: resolvePluginRuntimeName(undefined, authRuntime!.localPath, authConfig.name),
-          url: authRuntime!.url,
-          entry: authRuntime!.url ? `${authRuntime!.url}/mf-manifest.json` : "/mf-manifest.json",
-          localPath: authRuntime!.localPath,
-          port: authRuntime!.port,
-          source: authRuntime!.source,
-          proxy: authConfig.proxy,
-          variables: authConfig.variables,
-          secrets: authConfig.secrets,
-          integrity: authRuntime!.source === "remote" ? authConfig.integrity : undefined,
-        }
-      : undefined,
+    auth: (() => {
+      if (!authConfig || !authRuntime) return undefined;
+      return {
+        name: resolvePluginRuntimeName(undefined, authRuntime.localPath, authConfig.name),
+        url: authRuntime.url,
+        entry: authRuntime.url ? `${authRuntime.url}/mf-manifest.json` : "/mf-manifest.json",
+        localPath: authRuntime.localPath,
+        port: authRuntime.port,
+        source: authRuntime.source,
+        proxy: authConfig.proxy,
+        variables: authConfig.variables,
+        secrets: authConfig.secrets,
+        integrity: authRuntime.source === "remote" ? authConfig.integrity : undefined,
+        sidebar: authConfig.sidebar?.map((item) => ({
+          ...item,
+          to: item.to ?? "/auth",
+          roleRequired: item.roleRequired ?? ("member" as const),
+        })),
+      };
+    })(),
     plugins:
       options?.plugins && Object.keys(options.plugins).length > 0 ? options.plugins : undefined,
   };
@@ -276,74 +379,123 @@ async function resolveConfigWithExtends(
   baseDir: string,
   visited: Set<string>,
   chain: string[],
+  env: BosEnv = "development",
 ): Promise<BosConfigInput> {
   if (visited.has(configPath)) {
     throw new Error(`Circular extends detected: ${[...visited, configPath].join(" -> ")}`);
   }
 
   const config = await loadConfigFile(configPath, baseDir);
-  if (configPath.startsWith("bos://")) {
-    chain.push(configPath);
-  }
+  chain.push(configPath);
 
   if (!config.extends) {
     return config;
   }
 
+  const extendsRef = resolveExtendsRef(config.extends as string | ExtendsConfig, env);
+  if (!extendsRef) {
+    return config;
+  }
+
   const nextVisited = new Set(visited);
   nextVisited.add(configPath);
-  const parentPath = config.extends;
-  const parentBaseDir = parentPath.startsWith("bos://")
+  const parentBaseDir = extendsRef.startsWith("bos://")
     ? baseDir
-    : isAbsolute(parentPath)
-      ? dirname(parentPath)
+    : isAbsolute(extendsRef)
+      ? dirname(extendsRef)
       : baseDir;
-  const parent = await resolveConfigWithExtends(parentPath, parentBaseDir, nextVisited, chain);
+  const parent = await resolveConfigWithExtends(extendsRef, parentBaseDir, nextVisited, chain, env);
 
-  return mergeConfigs(parent, config);
+  return mergeBosConfigWithExtends(parent, config);
 }
 
-function mergeConfigs(parent: BosConfigInput, child: BosConfigInput): BosConfigInput {
-  const result = mergeValues(parent, child) as BosConfigInput;
-  if (child.plugins !== undefined) {
-    result.plugins = child.plugins;
+type PluginOverrideValue = PluginEntryValue | null | false;
+
+function normalizePluginEntry(raw: PluginOverrideValue): BosPluginRef | null | false {
+  if (raw === null || raw === false) return raw;
+  if (typeof raw === "string") {
+    return { extends: raw };
   }
-  return result;
+  return raw;
 }
 
 async function resolveRuntimePlugins(
-  plugins: Record<string, BosConfigInput>,
+  plugins: Record<string, PluginOverrideValue>,
   baseDir: string,
-  env: "development" | "production",
-  prefix: string[] = [],
+  env: BosEnv,
 ): Promise<Record<string, RuntimePluginConfig>> {
   const out: Record<string, RuntimePluginConfig> = {};
 
-  for (const [pluginId, pluginInput] of Object.entries(plugins)) {
-    const runtimeKey = [...prefix, pluginId].join("/");
-    const { config: resolvedConfig, baseDir: pluginBaseDir } = await resolveBosConfigInput(
-      pluginInput,
-      baseDir,
-      new Set(),
-      [],
-    );
+  for (const [pluginId, rawInput] of Object.entries(plugins)) {
+    const normalized = normalizePluginEntry(rawInput);
+    if (normalized === null || normalized === false) continue;
+
+    let resolvedConfig: BosConfigInput = {};
+    let pluginBaseDir = baseDir;
+
+    if (normalized.extends) {
+      try {
+        const extendsUrl = resolveExtendsRef(normalized.extends, env);
+        if (extendsUrl) {
+          const remoteConfig = await fetchBosConfigFromFastKv<BosConfigInput>(extendsUrl);
+          resolvedConfig = remoteConfig;
+        }
+      } catch {
+        resolvedConfig = {};
+      }
+    }
+
+    if (normalized.development?.startsWith(LOCAL_PREFIX)) {
+      const localPath = resolve(baseDir, normalized.development.slice(LOCAL_PREFIX.length).trim());
+      if (existsSync(localPath)) {
+        const localConfigPath = join(localPath, "bos.config.json");
+        if (existsSync(localConfigPath)) {
+          try {
+            const localRaw = JSON.parse(readFileSync(localConfigPath, "utf-8")) as BosConfigInput;
+            resolvedConfig = mergeBosConfigWithExtends(resolvedConfig, localRaw);
+            pluginBaseDir = localPath;
+          } catch {}
+        }
+      }
+    }
 
-    const pluginRuntime = buildRuntimePluginConfig(
-      runtimeKey,
+    if (normalized.app && isPlainObject(normalized.app)) {
+      const mergedApp: Record<string, unknown> = {
+        ...((resolvedConfig.app as Record<string, unknown>) ?? {}),
+        ...(normalized.app as Record<string, unknown>),
+      };
+      resolvedConfig = { ...resolvedConfig, app: mergedApp as BosConfigInput["app"] };
+    }
+    if (normalized.shared && isPlainObject(normalized.shared)) {
+      const mergedShared: Record<string, Record<string, SharedDepConfig>> = {
+        ...(resolvedConfig.shared ?? {}),
+        ...(normalized.shared as Record<string, Record<string, SharedDepConfig>>),
+      };
+      resolvedConfig = { ...resolvedConfig, shared: mergedShared };
+    }
+    if (normalized.sidebar) {
+      resolvedConfig = { ...resolvedConfig, sidebar: normalized.sidebar };
+    }
+    if (normalized.routes) {
+      resolvedConfig = { ...resolvedConfig, routes: normalized.routes };
+    }
+
+    const pluginRuntime = await buildRuntimePluginConfig(
+      pluginId,
       resolvedConfig,
       pluginBaseDir,
       env,
-      pluginInput,
+      normalized,
     );
     if (
-      pluginInput.name &&
-      typeof pluginInput.name === "string" &&
+      normalized.name &&
+      typeof normalized.name === "string" &&
       !pluginRuntime.name.includes("/")
     ) {
-      pluginRuntime.name = pluginInput.name;
+      pluginRuntime.name = normalized.name;
     }
 
-    const integrity = pluginInput.integrity;
+    const integrity = normalized.integrity;
     if (env === "production" && integrity) {
       pluginRuntime.integrity = integrity;
     }
@@ -353,7 +505,7 @@ async function resolveRuntimePlugins(
       pluginRuntime.url &&
       !pluginRuntime.localPath &&
       typeof resolvedConfig.app?.api?.name !== "string" &&
-      !pluginInput.name
+      !normalized.name
     ) {
       pluginRuntime.name = await resolveRemotePluginRuntimeName(
         pluginRuntime.url,
@@ -361,15 +513,7 @@ async function resolveRuntimePlugins(
       );
     }
 
-    out[runtimeKey] = pluginRuntime;
-
-    if (resolvedConfig.plugins && Object.keys(resolvedConfig.plugins).length > 0) {
-      const nested = await resolveRuntimePlugins(resolvedConfig.plugins, pluginBaseDir, env, [
-        ...prefix,
-        pluginId,
-      ]);
-      Object.assign(out, nested);
-    }
+    out[pluginId] = pluginRuntime;
   }
 
   return out;
@@ -377,7 +521,13 @@ async function resolveRuntimePlugins(
 
 async function resolveRemotePluginRuntimeName(baseUrl: string, fallback: string): Promise<string> {
   try {
-    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/plugin.manifest.json`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/plugin.manifest.json`, {
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+
     if (!response.ok) {
       return fallback;
     }
@@ -394,13 +544,38 @@ async function resolveRemotePluginRuntimeName(baseUrl: string, fallback: string)
   }
 }
 
-function buildRuntimePluginConfig(
+interface ResolvedBosPlugin {
+  url: string;
+  integrity?: string;
+}
+
+async function resolveBosPluginUrl(bosUrl: string): Promise<ResolvedBosPlugin | null> {
+  const parsed = parsePluginBosUrl(bosUrl);
+  if (!parsed) return null;
+
+  try {
+    const entry = await fetchPluginFromRegistry(parsed.accountId, parsed.pluginName);
+    if (!entry) return null;
+
+    const cdnUrl = entry.metadata.cdnUrl;
+    if (!cdnUrl) return null;
+
+    return {
+      url: cdnUrl,
+      integrity: entry.metadata.integrity ?? undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function buildRuntimePluginConfig(
   pluginId: string,
   config: BosConfigInput,
   baseDir: string,
-  env: "development" | "production",
-  source: BosConfigInput,
-): RuntimePluginConfig {
+  env: BosEnv,
+  source: BosPluginRef,
+): Promise<RuntimePluginConfig> {
   const apiConfig = config.app?.api ?? {};
   const apiDevelopment =
     typeof apiConfig.development === "string" ? apiConfig.development : undefined;
@@ -409,7 +584,18 @@ function buildRuntimePluginConfig(
   const sourceProduction = typeof source.production === "string" ? source.production : undefined;
   const proxy = typeof apiConfig.proxy === "string" ? apiConfig.proxy : undefined;
   const development = apiDevelopment ?? sourceDevelopment;
-  const production = apiProduction ?? sourceProduction;
+  let production = apiProduction ?? sourceProduction;
+
+  if (production?.startsWith("bos://")) {
+    const resolved = await resolveBosPluginUrl(production);
+    if (resolved) {
+      production = resolved.url;
+      if (resolved.integrity && env === "production") {
+        source.integrity = resolved.integrity;
+      }
+    }
+  }
+
   const runtimeTarget =
     env === "development"
       ? resolveDevelopmentTarget(development, production, baseDir)
@@ -420,6 +606,25 @@ function buildRuntimePluginConfig(
     pluginId,
   );
 
+  const uiConfig = config.app?.ui;
+  const uiDevelopment =
+    typeof uiConfig?.development === "string" ? uiConfig.development : undefined;
+  const uiProduction = typeof uiConfig?.production === "string" ? uiConfig.production : undefined;
+  const uiRuntime =
+    uiConfig && (uiDevelopment || uiProduction)
+      ? env === "development"
+        ? resolveDevelopmentTarget(uiDevelopment, uiProduction, baseDir)
+        : resolveRuntimeTarget(uiProduction, baseDir, "remote")
+      : undefined;
+
+  const sidebar = (config.sidebar ?? source.sidebar)?.map((item) => ({
+    ...item,
+    to: item.to ?? `/${pluginId}`,
+    roleRequired: item.roleRequired ?? ("member" as const),
+  }));
+
+  const routes = config.routes ?? source.routes;
+
   return {
     name: apiName,
     url: runtimeTarget.url,
@@ -432,6 +637,24 @@ function buildRuntimePluginConfig(
     proxy: proxy ?? (typeof source.proxy === "string" ? source.proxy : undefined),
     variables: normalizeStringRecord(apiConfig.variables ?? source.variables),
     secrets: normalizeStringArray(apiConfig.secrets ?? source.secrets),
+    ui: uiRuntime
+      ? {
+          name: typeof uiConfig?.name === "string" ? uiConfig.name : `${apiName}-ui`,
+          url: uiRuntime.url,
+          entry: uiRuntime.url
+            ? `${uiRuntime.url.replace(/\/$/, "")}/mf-manifest.json`
+            : "/mf-manifest.json",
+          source: uiRuntime.source,
+          localPath: uiRuntime.localPath,
+          port: uiRuntime.port,
+          integrity:
+            uiRuntime.source === "remote" && typeof uiConfig?.integrity === "string"
+              ? uiConfig.integrity
+              : undefined,
+        }
+      : undefined,
+    sidebar,
+    routes,
   };
 }
 
@@ -459,45 +682,6 @@ export function resolvePluginRuntimeName(
   return fallback;
 }
 
-async function resolveBosConfigInput(
-  input: BosConfigInput,
-  baseDir: string,
-  visited: Set<string>,
-  chain: string[],
-): Promise<{ config: BosConfigInput; baseDir: string }> {
-  if (input.extends) {
-    const parentBaseDir = input.extends.startsWith("bos://")
-      ? baseDir
-      : isAbsolute(input.extends)
-        ? dirname(input.extends)
-        : baseDir;
-    const config = await resolveConfigWithExtends(input.extends, parentBaseDir, visited, chain);
-    return { config: mergeConfigs(config, input), baseDir: parentBaseDir };
-  }
-
-  return { config: input, baseDir };
-}
-
-function mergeValues(parent: unknown, child: unknown): unknown {
-  if (Array.isArray(parent) && Array.isArray(child)) {
-    return child;
-  }
-
-  if (isPlainObject(parent) && isPlainObject(child)) {
-    const merged: Record<string, unknown> = { ...parent };
-    for (const [key, value] of Object.entries(child)) {
-      merged[key] = key in merged ? mergeValues(merged[key], value) : value;
-    }
-    return merged;
-  }
-
-  return child ?? parent;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
 function normalizeStringRecord(value: unknown): Record<string, string> | undefined {
   if (!isPlainObject(value)) return undefined;
   const out: Record<string, string> = {};
@@ -525,7 +709,7 @@ function resolveRuntimeTarget(
   }
 
   if (value.startsWith(LOCAL_PREFIX)) {
-    const localTarget = value.slice(LOCAL_PREFIX.length).trim();
+    const localTarget = value?.slice(LOCAL_PREFIX.length).trim();
     if (!localTarget) {
       throw new Error(`Invalid local development target: ${value}`);
     }
@@ -549,7 +733,9 @@ function resolveRuntimeTarget(
   };
 }
 
-export function isLocalDevelopmentTarget(value: string | undefined): boolean {
+export function isLocalDevelopmentTarget(
+  value: string | undefined,
+): value is `${typeof LOCAL_PREFIX}${string}` {
   return typeof value === "string" && value.startsWith(LOCAL_PREFIX);
 }
 
@@ -561,7 +747,7 @@ export function resolveLocalDevelopmentPath(
     return null;
   }
 
-  const localTarget = value!.slice(LOCAL_PREFIX.length).trim();
+  const localTarget = value.slice(LOCAL_PREFIX.length).trim();
   return localTarget ? resolve(baseDir, localTarget) : null;
 }
 
@@ -586,5 +772,6 @@ export function parsePort(url: string): number {
   }
 }
 
+export { BOS_CONFIG_ORDER, rebuildOrderedConfig } from "./merge";
 export type { BosConfig, RuntimeConfig } from "./types";
 export { BosConfigSchema } from "./types";

package/src/host.ts

@@ -54,6 +54,15 @@ function buildClientRuntimeConfig(runtimeConfig: RuntimeConfig): ClientRuntimeCo
           integrity: runtimeConfig.api.integrity,
         }
       : undefined,
+    auth: runtimeConfig.auth
+      ? {
+          name: runtimeConfig.auth.name,
+          url: runtimeConfig.auth.url,
+          entry: runtimeConfig.auth.entry,
+          integrity: runtimeConfig.auth.integrity,
+          sidebar: runtimeConfig.auth.sidebar,
+        }
+      : undefined,
     plugins: runtimeConfig.plugins
       ? Object.fromEntries(
           Object.entries(runtimeConfig.plugins).map(([key, plugin]) => [
@@ -63,6 +72,18 @@ function buildClientRuntimeConfig(runtimeConfig: RuntimeConfig): ClientRuntimeCo
               url: plugin.url,
               entry: plugin.entry,
               integrity: plugin.integrity,
+              ...(plugin.ui
+                ? {
+                    ui: {
+                      name: plugin.ui.name,
+                      url: plugin.ui.url,
+                      entry: plugin.ui.entry,
+                      source: plugin.ui.source,
+                      integrity: plugin.ui.integrity,
+                    },
+                  }
+                : {}),
+              ...(plugin.sidebar ? { sidebar: plugin.sidebar } : {}),
             },
           ]),
         )
@@ -79,6 +100,15 @@ function renderLoadingShell(runtimeConfig: ClientRuntimeConfig, error?: string |
   const uiIntegrity = runtimeConfig.ui?.integrity;
   const sriAttr = uiIntegrity ? ` integrity="${uiIntegrity}" crossorigin="anonymous"` : "";
 
+  const pluginUiScripts = Object.values(runtimeConfig.plugins ?? {})
+    .filter((plugin) => plugin.ui?.url && plugin.ui.source === "remote")
+    .map((plugin) => {
+      const uiIntegrity = plugin.ui!.integrity;
+      const sri = uiIntegrity ? ` integrity="${uiIntegrity}" crossorigin="anonymous"` : "";
+      return `<script src="${plugin.ui!.url}/remoteEntry.js"${sri}></script>`;
+    })
+    .join("\n");
+
   return `
 		<!DOCTYPE html>
 		<html lang="en">
@@ -92,6 +122,7 @@ function renderLoadingShell(runtimeConfig: ClientRuntimeConfig, error?: string |
 					@keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
 				</style>
 				${runtimeConfig.assetsUrl ? `<script src="${runtimeConfig.assetsUrl}/remoteEntry.js"${sriAttr}></script>` : ""}
+				${pluginUiScripts}
 				<script>${bootstrap}</script>
 			</head>
 			<body>
@@ -454,6 +485,20 @@ async function runHostServer(opts: {
     }
   }
 
+  for (const [pluginKey, pluginConfig] of Object.entries(runtimeConfig.plugins ?? {})) {
+    if (!pluginConfig.ui?.url) continue;
+    const pluginUiUrl = pluginConfig.ui.url;
+    const proxyPrefix = `/__mf/plugin-ui/${pluginKey}`;
+    app.all(`${proxyPrefix}/*`, async (c) => {
+      const targetUrl = `${pluginUiUrl}${c.req.path.replace(proxyPrefix, "")}`;
+      const response = await fetch(targetUrl, {
+        method: c.req.method,
+        headers: c.req.header(),
+      });
+      return response;
+    });
+  }
+
   app.get("*", async (c) => {
     const routerModule = await ensureRouterModuleLoaded();