@aaqu/fromcubes-portal-react 0.1.0-alpha.23 → 0.1.0-alpha.25

package/README.md

@@ -227,7 +227,8 @@ Import **Shared Components** first — it provides the UI building blocks (Page,
 | Red status "legacy endpoint" on deploy | Flow was saved before the `/fromcubes/` prefix became hardcoded. Open the node, set **Sub-path**, redeploy. Automatic migration is disabled to avoid silent URL changes. |
 | Red status "bad sub-path" | Sub-path is empty or violates the rules (no leading `/`, no whitespace, no `..`, segments must start alphanumerically, `public`/`_ws` reserved). |
 | Yellow status "css-fail" | Tailwind generation failed (usually an invalid class in JSX). Page still loads but unstyled. Fix the class, redeploy — the status clears on the next successful build. |
-| `npm install @aaqu/fromcubes-portal-react` ends with `EACCES` on `postinstall` | `scripts/sync-resources.js` copies Monaco into `resources/vs/` after install. The Node-RED `userDir/node_modules/...` install path must be writable by the user running Node-RED. Re-run `npm install` from a shell with the right ownership. |
+| Code editor stays blank / `portal-react/vs/loader.js` 404s | Monaco is served live from the package's own `node_modules` at `/portal-react/vs` (no postinstall copy step). The 404 means `RED.httpAdmin` is mounted under a non-root `httpAdminRoot` the editor didn't account for, or `monaco-editor` failed to install. Reinstall the package and hard-refresh the editor (`Cmd/Ctrl-Shift-R`). |
+| `npm install @aaqu/fromcubes-portal-react` ends with `EACCES` | The Node-RED `userDir/node_modules` install path is not writable by the user running Node-RED. Re-run `npm install` from a shell with the right ownership. |
 | Browser request `/portal-react/css/<hash>.css` returns 404 | The portal's deploy hasn't produced a CSS bundle yet — open the editor, redeploy. If the URL is bookmarked from before a deploy, the hash is stale; reload the portal page itself. |
 | WebSocket reconnects in an endless loop | Reverse-proxy is not forwarding `Upgrade: websocket` on `/fromcubes/<sub-path>/_ws`. Check the proxy config — nginx needs `proxy_set_header Upgrade $http_upgrade`, Traefik needs the `websocket` middleware. |
 | `libs` packages fail to install on deploy | The user-installed npm packages declared in **Libs** install via Node-RED's `dynamicModuleList` mechanism, which needs network access from `userDir` and a writable `node_modules`. Behind a corporate proxy set `npm config set proxy …` for the Node-RED user. |

package/nodes/lib/helpers.js

@@ -363,6 +363,44 @@ function findMissingComponentRefs(userCode, knownNames) {
   return missing;
 }
 
+/**
+ * Resolve the content hash the server may advertise to a browser over the WS
+ * `version` frame. The hash MUST only be non-empty when there is a page the
+ * GET route can actually serve — otherwise a stale hash makes the served error
+ * / building page reload in a tight loop (it reloads on any non-empty
+ * `version` hash).
+ *
+ * States, in order:
+ *   - no state / nulled `compiled` (post-`close` teardown window) → ""
+ *   - degraded (build error but a previous good build is kept) → lastGood hash
+ *   - hard build error with no fallback → ""
+ *   - real serveable build (`compiled.js` present) → contentHash
+ *
+ * @param {?PageState} state  pageState[endpoint] (may be null/partially torn down).
+ * @returns {string}          Hash to advertise, or "" when nothing is serveable.
+ */
+function serveableHash(state) {
+  if (!state || !state.compiled) return "";
+  if (state.compiled.error) {
+    return state.lastGood ? state.lastGood.contentHash || "" : "";
+  }
+  return state.compiled.js ? state.contentHash || "" : "";
+}
+
+/**
+ * True only when `state` holds a real, serveable build. Used by the no-op
+ * redeploy guard to decide whether a rebuild can be skipped. MUST be false
+ * after close() nulls `compiled` (`{ ...compiled: null }` teardown window),
+ * otherwise the guard treats the destroyed build as valid, skips the rebuild,
+ * and the GET route serves the holding page forever (permanent spinner).
+ *
+ * @param {?PageState} state  pageState[endpoint] (may be null/torn down).
+ * @returns {boolean}
+ */
+function hasFreshBuild(state) {
+  return !!state && !state.building && !!state.compiled && !state.compiled.error;
+}
+
 module.exports = function (RED) {
   return createHelpers(RED);
 };
@@ -373,6 +411,8 @@ module.exports.quickCheckSyntax = quickCheckSyntax;
 module.exports.formatEsbuildError = formatEsbuildError;
 module.exports.extractPortalUser = extractPortalUser;
 module.exports.findMissingComponentRefs = findMissingComponentRefs;
+module.exports.serveableHash = serveableHash;
+module.exports.hasFreshBuild = hasFreshBuild;
 module.exports.NAME_MAX_LEN = NAME_MAX_LEN;
 module.exports.MAX_GROUPS_HEADER_BYTES = MAX_GROUPS_HEADER_BYTES;
 
@@ -593,6 +633,8 @@ function createHelpers(RED) {
     quickCheckSyntax,
     generateCSS,
     extractPortalUser,
+    serveableHash,
+    hasFreshBuild,
     removeRoute,
     isSafeName,
     validateSubPath,

package/nodes/lib/page-builder.js

@@ -218,6 +218,16 @@ function buildPage(title, transpiledJs, wsPath, customHead, cssHash, user, showW
           // Flushed in onopen so node status can go red even when the
           // exception fires synchronously during initial bundle execution.
           _pendingRuntimeError: null,
+          // Page-load timestamp + guarded reload: never reload within 2s of
+          // load, so a briefly-inconsistent server (error page served while a
+          // "ready" version hash is advertised over WS) cannot drive a tight
+          // reload loop. Caps recovery to one reload / 2s.
+          _loadT: Date.now(),
+          _reload() {
+            const wait = 2000 - (Date.now() - this._loadT);
+            if (wait > 0) setTimeout(() => location.reload(), wait);
+            else location.reload();
+          },
           _user: ${user ? escScript(JSON.stringify(user)) : "null"},
 
           connect() {
@@ -253,7 +263,7 @@ function buildPage(title, transpiledJs, wsPath, customHead, cssHash, user, showW
                   // exception caught locally renders the same overlay node and would
                   // otherwise loop reload to runtime-error to reload forever.
                   if (this._buildErrorActive || (this._version && this._version !== m.hash)) {
-                    location.reload();
+                    this._reload();
                     return;
                   }
                   this._version = m.hash;
@@ -379,6 +389,16 @@ function buildErrorPage(title, error, wsPath) {
           const st = document.getElementById('__err_status');
           const pre = document.querySelector('#__error_overlay pre');
           let retries = 0;
+          // Reload guard: never reload within 2s of this page loading. If the
+          // server is briefly inconsistent (serves this error page yet
+          // advertises a "ready" version hash over WS), an unguarded reload
+          // turns into a tight loop. The guard caps it to one reload / 2s.
+          const __loadT = Date.now();
+          function __reload() {
+            const wait = 2000 - (Date.now() - __loadT);
+            if (wait > 0) { setTimeout(function(){ location.reload(); }, wait); }
+            else { location.reload(); }
+          }
           function setStatus(text, ok) {
             if (!st) return;
             st.textContent = text;
@@ -394,7 +414,7 @@ function buildErrorPage(title, error, wsPath) {
             ws.onmessage = function(e) {
               try {
                 const m = JSON.parse(e.data);
-                if (m.type === 'version' && m.hash) location.reload();
+                if (m.type === 'version' && m.hash) __reload();
                 if (m.type === 'error' && pre) pre.textContent = m.message;
               } catch(_) {}
             };

package/nodes/portal-react.js

@@ -544,6 +544,8 @@ module.exports = function (RED) {
     quickCheckSyntax,
     generateCSS,
     extractPortalUser,
+    serveableHash,
+    hasFreshBuild,
     removeRoute,
     isSafeName,
     validateSubPath,
@@ -1548,8 +1550,11 @@ module.exports = function (RED) {
     );
     const prevSig = portalSig[nodeId];
     const existing = pageState[endpoint];
-    const hasValidBuild =
-      !!existing && !existing.building && !existing.compiled?.error;
+    // hasFreshBuild also requires `compiled` to be present — close() nulls it on
+    // redeploy, and a guard that ignored that (checking only building/error)
+    // would treat the destroyed build as valid and skip the rebuild, leaving the
+    // GET route serving the holding page forever. See helpers.hasFreshBuild.
+    const hasValidBuild = hasFreshBuild(existing);
     portalSig[nodeId] = sig;
 
     if (prevSig !== sig || !hasValidBuild) {
@@ -1564,7 +1569,11 @@ module.exports = function (RED) {
         RED.httpNode.get(endpoint, async function (_req, res) {
           try {
             const state = pageState[endpoint];
-            if (!state || state.building) {
+            // `!state.compiled` is the teardown window between node close
+            // (which nulls compiled) and the next rebuild. Treat it like
+            // "building" — serve the holding page (200), never fall through to
+            // `state.compiled.error` which would throw and 500 via the catch.
+            if (!state || state.building || !state.compiled) {
               const bWsPath = state?.wsPath || wsPath;
               res
                 .set("Cache-Control", "no-store")
@@ -1721,10 +1730,11 @@ module.exports = function (RED) {
           // In degraded mode (current build failed but lastGood served), advertise
           // the lastGood hash so the freshly reloaded client matches the JS we sent.
           const cs = pageState[endpoint];
-          const contentHash =
-            cs?.compiled?.error && cs?.lastGood
-              ? cs.lastGood.contentHash
-              : cs?.contentHash || "";
+          // Only advertise a non-empty hash when there is a page the GET route
+          // can actually serve (real build, or degraded lastGood). Advertising
+          // a stale hash for a nulled/error state drives the served error page
+          // into a reload loop. See helpers.serveableHash.
+          const contentHash = serveableHash(cs);
           wsSend(ws, { type: "version", hash: contentHash });
 
           // Send assigned portalClient to browser
@@ -1964,6 +1974,11 @@ module.exports = function (RED) {
             st.cssReady = null;
             st.compiled = null;
             st.css = null;
+            // Clear the advertised hash too. Leaving a stale non-empty
+            // contentHash while compiled is null makes the WS `version` frame
+            // advertise a "ready" page that the GET route can no longer serve,
+            // which drives the served error/building page into a reload loop.
+            st.contentHash = "";
           }
 
           // Clean up route only on full removal/disable (not on redeploy).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaqu/fromcubes-portal-react",
-  "version": "0.1.0-alpha.23",
+  "version": "0.1.0-alpha.25",
   "description": "Fromcubes Portal - React for Node-RED with Tailwind CSS and auto complete",
   "type": "commonjs",
   "keywords": [