mango-cms 0.3.27 → 0.3.28

package/lib/devProxyGateway.js

@@ -282,9 +282,18 @@ export function createHttpResolver({
  *   - Matching staging host → resolve via Mango → http-proxy to the workspace port.
  *   - WebSocket upgrade (Vite HMR) → same resolution → proxy.ws to the same port.
  *   - Non-staging host → 404 with a clear message (no misroute).
- *   - Resolver errors (401/403/404/502) → surfaced as the resolver's HTTP status.
+ *   - Resolver errors (403/404/502) → surfaced as the resolver's HTTP status.
  *   - Upgrade-time resolver failure → socket destroyed (Vite retries the WS).
  *
+ * Page-load auth (HAP-1173): a top-level browser navigation (`GET /`) carries
+ * neither Cookie nor Authorization — the Vibe front's session is a localStorage
+ * token attached only to explicit fetch/XHR. If the gateway gated those on auth
+ * the editing surface couldn't load at all. So when `fallbackPort` is configured
+ * AND the request has no Cookie + no Authorization, the gateway proxies the
+ * request to that port (the shared front) instead of 401-ing. Branch selection
+ * happens client-side after the SPA loads; subsequent authenticated calls carry
+ * `x-vibe-branch` and resolve to the per-branch workspace as before.
+ *
  * Returns { server, proxy, close() } — caller owns server.listen(port, host).
  */
 export function createStagingGatewayServer({
@@ -295,6 +304,7 @@ export function createStagingGatewayServer({
     backendPort,
     resolverPath,
     timeoutMs,
+    fallbackPort,
     onError,
 } = {}) {
     if (!http || typeof http.createServer !== 'function') {
@@ -306,9 +316,16 @@ export function createStagingGatewayServer({
     if (!Number.isInteger(backendPort)) {
         throw new Error('createStagingGatewayServer: backendPort (integer) is required')
     }
+    if (fallbackPort != null && (!Number.isInteger(fallbackPort) || fallbackPort <= 0 || fallbackPort > 65535)) {
+        throw new Error('createStagingGatewayServer: fallbackPort, if set, must be an integer in 1..65535')
+    }
 
     const resolve = createHttpResolver({ backendPort, resolverPath, timeoutMs, http })
     const proxy = httpProxy.createProxyServer({ ws: true, xfwd: true })
+    const fallbackTarget = Number.isInteger(fallbackPort) ? `http://127.0.0.1:${fallbackPort}` : null
+    function isUnauthenticated(req) {
+        return !(req?.headers?.cookie) && !(req?.headers?.authorization)
+    }
 
     const log = (where, err, req) => {
         if (typeof onError === 'function') onError(where, err, req)
@@ -342,6 +359,15 @@ export function createStagingGatewayServer({
             sendError(res, 404, `Unknown host: ${req?.headers?.host || '(missing Host header)'}`)
             return
         }
+        // HAP-1173: a raw browser navigation carries no Cookie + no Authorization
+        // (the front's session is a localStorage token attached only to fetch/XHR).
+        // Without a fallback the SPA shell can't load → editing surface is dead.
+        // With one configured, serve page + assets from the shared front; the
+        // branch picker fires client-side and later authenticated calls demux.
+        if (fallbackTarget && isUnauthenticated(req)) {
+            proxy.web(req, res, { target: fallbackTarget })
+            return
+        }
         const outcome = await resolveStagingTarget({ req, slug: parsed.slug, resolve })
         if (outcome.error) {
             sendError(res, outcome.status || 502, outcome.message || outcome.error)
@@ -356,6 +382,14 @@ export function createStagingGatewayServer({
             try { socket.destroy() } catch { /* noop */ }
             return
         }
+        // Page-load HMR upgrade rides without auth on the very first connect
+        // (same reason as handleRequest above). Send it to the fallback front so
+        // Vite HMR works for the un-routed shell; once the user picks a branch,
+        // the next upgrade carries `x-vibe-branch` and routes per-branch.
+        if (fallbackTarget && isUnauthenticated(req)) {
+            proxy.ws(req, socket, head, { target: fallbackTarget })
+            return
+        }
         const outcome = await resolveStagingTarget({ req, slug: parsed.slug, resolve })
         if (outcome.error) {
             // Don't write an HTTP response onto an upgrade socket — Vite retries.

package/lib/staging-gateway.js

@@ -18,6 +18,11 @@
  *   STAGING_HOST_PREFIX  (default "staging.")  Prefix fallback for slug demux.
  *   RESOLVER_PATH   (default /system/vibe/staging-resolve)
  *   RESOLVER_TIMEOUT_MS (default 2000, int)
+ *   FALLBACK_PORT   (default 7121, int)  Where to send requests with no Cookie
+ *                                        and no Authorization header — i.e. a
+ *                                        browser page-load (HAP-1173). Usually
+ *                                        the site's shared front. Set to 0 to
+ *                                        disable and 401 those requests instead.
  *
  * Usage (typical droplet pm2):
  *   BACKEND_PORT=7122 LISTEN_PORT=7123 \
@@ -40,6 +45,19 @@ function intEnv(name, fallback) {
     return n
 }
 
+function fallbackPortEnv() {
+    // Allow `FALLBACK_PORT=0` to opt out (page-loads → 401, the pre-1173 behavior).
+    const raw = process.env.FALLBACK_PORT
+    if (raw === undefined) return 7121
+    if (raw === '' || raw === '0') return null
+    const n = parseInt(raw, 10)
+    if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+        console.error(`[staging-gateway] FALLBACK_PORT must be a port in 1..65535 or 0/empty (got "${raw}")`)
+        process.exit(1)
+    }
+    return n
+}
+
 const BACKEND_PORT = intEnv('BACKEND_PORT', null)
 if (BACKEND_PORT === null) {
     console.error('[staging-gateway] BACKEND_PORT (int) is required')
@@ -52,6 +70,7 @@ const STAGING_DOMAIN = process.env.STAGING_DOMAIN || ''
 const STAGING_HOST_PREFIX = process.env.STAGING_HOST_PREFIX || undefined
 const RESOLVER_PATH = process.env.RESOLVER_PATH || undefined
 const RESOLVER_TIMEOUT_MS = intEnv('RESOLVER_TIMEOUT_MS', 2000)
+const FALLBACK_PORT = fallbackPortEnv()
 
 const { server, close } = createStagingGatewayServer({
     http,
@@ -61,6 +80,7 @@ const { server, close } = createStagingGatewayServer({
     backendPort: BACKEND_PORT,
     resolverPath: RESOLVER_PATH,
     timeoutMs: RESOLVER_TIMEOUT_MS,
+    fallbackPort: FALLBACK_PORT,
     onError: (where, err) => {
         console.error(`[staging-gateway] ${where} error: ${err?.message || err}`)
     },
@@ -70,6 +90,11 @@ server.listen(LISTEN_PORT, LISTEN_HOST, () => {
     const target = STAGING_DOMAIN || `${STAGING_HOST_PREFIX || 'staging.'}*`
     console.log(`[staging-gateway] listening on ${LISTEN_HOST}:${LISTEN_PORT}`)
     console.log(`[staging-gateway]   ${target}  ->  per-branch Vibe workspace (resolved via 127.0.0.1:${BACKEND_PORT})`)
+    if (FALLBACK_PORT) {
+        console.log(`[staging-gateway]   page-load (no Cookie + no Authorization)  ->  127.0.0.1:${FALLBACK_PORT}`)
+    } else {
+        console.log('[staging-gateway]   page-load fallback disabled (no Cookie + no Authorization → 401)')
+    }
 })
 
 function shutdown(signal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mango-cms",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "type": "module",
   "main": "./index.js",
   "exports": {