@reventlessdev/reventless-host-shell 3.0.0-alpha.73 → 3.0.0-alpha.75

package/dist/mf-entry-bootstrap-0.js

@@ -14,4 +14,4 @@ const __mfImport = (src) =>
   const runtime = await initHost();
   const __mfRemotePreloads = [];
   await Promise.all(__mfRemotePreloads);
-})().then(() => __mfImport("/assets/index-BLP8Blsh.js"));
+})().then(() => __mfImport("/assets/index-D-WAM7fJ.js"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-host-shell",
-  "version": "3.0.0-alpha.73",
+  "version": "3.0.0-alpha.75",
   "description": "Reventless host shell SPA — loads plugin UI fragments at runtime via Module Federation",
   "license": "SEE LICENSE IN LICENSE",
   "bin": {
@@ -28,10 +28,10 @@
     "@aws-sdk/client-cognito-identity-provider": "^3.658.0",
     "@module-federation/runtime": "^0.18.0",
     "@rescript/react": "^0.13.1",
-    "@reventlessdev/reventless-graph": "0.1.0-alpha.30",
-    "@reventlessdev/reventless-map": "0.1.0-alpha.30",
+    "@reventlessdev/reventless-graph": "0.1.0-alpha.32",
+    "@reventlessdev/reventless-map": "0.1.0-alpha.32",
     "@reventlessdev/reventless-routes": "3.0.0-alpha.12",
-    "@reventlesslab/reventless-ui": "3.0.0-alpha.69",
+    "@reventlesslab/reventless-ui": "3.0.0-alpha.71",
     "graphql-ws": "^5.16.0",
     "jwt-decode": "^4.0.0",
     "react": "^18.3.1",
@@ -46,5 +46,5 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "gitHead": "3ebbb145dbd9e9c7f074688e14e9aad444b1d5cb"
+  "gitHead": "2ba054988e8de48508ac43b9131b101d7d1d3c55"
 }

package/vite.config.mjs

@@ -1,4 +1,6 @@
 import { federation } from "@module-federation/vite"
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
 
 // The host shell ships with no build-time remotes. Plugin remotes are
 // discovered at runtime via the Platform_UIFragments GraphQL query and
@@ -51,8 +53,134 @@ const proxy = {
   },
 }
 
+// The four files a running platform overlays into the shell's served assets.
+// `config.json` and `ui-hints.json` exist in `public/` too and are overridden;
+// the manifests exist nowhere else, so without this they simply 404.
+const overlaidFile = path =>
+  path === "/config.json" ||
+  path === "/ui-hints.json" ||
+  /^\/component-manifest[a-zA-Z0-9._-]*\.json$/.test(path)
+
+// A directory is the running platform's served assets only if it holds
+// `config.base.json`. That file is written by exactly one thing — the local
+// platform putting the shipped `config.json` aside before it overlays it — so
+// its presence is the fact "a platform has served from here", not a guess. It is
+// what keeps discovery off this package's own `dist/`, which carries the same
+// file names and none of the platform's answers.
+const servedAssets = dir => {
+  const dist = dir.endsWith("dist") ? dir : join(dir, "node_modules/@reventlessdev/reventless-host-shell/dist")
+  return existsSync(join(dist, "config.base.json")) ? dist : null
+}
+
+const subdirs = dir => {
+  try {
+    return readdirSync(dir)
+      .filter(n => !n.startsWith(".") && n !== "node_modules")
+      .map(n => join(dir, n))
+      .filter(p => {
+        try {
+          return statSync(p).isDirectory()
+        } catch {
+          return false
+        }
+      })
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Where the running platform put the files it overlays.
+ *
+ * `REVENTLESS_PLATFORM_DIR` wins and is the only thing that always works: it
+ * names the directory the platform runs from, which is where `HostShellDist`
+ * resolves the package from on that side. Point it at a platform root (or
+ * straight at a dist) and the two cannot disagree.
+ *
+ * Unset, we look. Ancestors of the cwd first, then the immediate siblings of the
+ * checkout this file lives in — a platform in a co-located repo is the ordinary
+ * arrangement for anyone running the UI from source, and the `config.base.json`
+ * gate means a wrong candidate is skipped rather than served.
+ */
+const findServedAssets = () => {
+  const declared = process.env.REVENTLESS_PLATFORM_DIR ?? process.env.REVENTLESS_SHELL_DIST
+  if (declared) {
+    const found = servedAssets(resolve(declared))
+    return found
+      ? { dist: found, from: "REVENTLESS_PLATFORM_DIR" }
+      : { dist: null, from: `REVENTLESS_PLATFORM_DIR (${declared}) — no config.base.json under it` }
+  }
+
+  const ancestors = []
+  for (let dir = process.cwd(); ; dir = dirname(dir)) {
+    ancestors.push(dir)
+    if (dirname(dir) === dir) break
+  }
+  const checkout = ancestors.find(d => existsSync(join(d, ".git"))) ?? process.cwd()
+
+  for (const candidate of [...ancestors, ...subdirs(dirname(checkout))]) {
+    const found = servedAssets(candidate)
+    if (found) return { dist: found, from: "discovered" }
+  }
+  return { dist: null, from: "not found" }
+}
+
+/**
+ * Serve the running platform's overlaid assets instead of this package's `public/`.
+ *
+ * A platform states its shell's surface by writing into the served assets of the
+ * `@reventlessdev/reventless-host-shell` it resolves: `manifestUrl`,
+ * `journeyManifestUrls` and `elevatedGroups` onto `config.json`, the baked
+ * manifests beside it, the deployment's own `ui-hints.json` over the one this
+ * package ships. Running the shell from source serves `public/` instead, so none
+ * of it arrives — and the shell reads a config with no `manifestUrl` as "this
+ * deployment discovers from the admin query alone". Every caller then needs the
+ * Admin group, which is precisely what acting as a role gives up: switching role
+ * narrows the token to that role, the admin query refuses it, and the shell
+ * reports that the role has no surfaces. The deployment had configured one.
+ *
+ * Re-read per request rather than cached, because both ends already move: the
+ * platform rewrites `config.json` on every boot, and re-serves `ui-hints.json`
+ * on every save so a label change restacks the menu where it stands.
+ */
+const platformAssets = () => {
+  let resolved
+  const handler = (req, res, next) => {
+    resolved ??= findServedAssets()
+    const path = (req.url ?? "").split("?")[0]
+    if (!resolved.dist || !overlaidFile(path)) return next()
+    const file = join(resolved.dist, path)
+    if (!existsSync(file)) return next()
+    res.setHeader("Content-Type", "application/json")
+    res.setHeader("Cache-Control", "no-store")
+    res.end(readFileSync(file))
+  }
+  const announce = logger => {
+    resolved ??= findServedAssets()
+    logger.info(
+      resolved.dist
+        ? `  ➜  platform assets: ${resolved.dist} (${resolved.from})`
+        : `  ➜  platform assets: none (${resolved.from}) — serving public/, so config.json carries no ` +
+          `manifestUrl and acting as a role will find no surfaces. Set REVENTLESS_PLATFORM_DIR to the ` +
+          `directory your platform runs from.`,
+    )
+  }
+  return {
+    name: "reventless-platform-assets",
+    apply: "serve",
+    configureServer: server => {
+      server.middlewares.use(handler)
+      announce(server.config.logger)
+    },
+    configurePreviewServer: server => {
+      server.middlewares.use(handler)
+      announce(server.config.logger)
+    },
+  }
+}
+
 export default {
-  plugins: [mfPlugin],
+  plugins: [mfPlugin, platformAssets()],
   build: {
     target: "esnext",
     outDir: "dist",