mango-cms 0.3.25 → 0.3.26

package/lib/dev-proxy.js

@@ -50,7 +50,8 @@ proxy.on('error', (err, req, res) => {
 });
 
 // Production resolver for the staging route: hits a small Mango endpoint that
-// resolves (cookie/auth → memberId) and looks up vibeWorkspaces by (userId, slug).
+// authorizes the member (cookie/auth) and looks up vibeWorkspaces by the selected
+// (site, branch) — the branch travels with the request (HAP-1164).
 const stagingResolver = createHttpResolver({ backendPort, http });
 
 function getTarget(host) {

package/lib/devProxyGateway.js

@@ -17,14 +17,45 @@
  * Cookie / Authorization headers to Mango on the backend port — Mango identifies
  * the member (`req.session.memberId` for the session cookie, member by
  * password-hash for the Authorization header — same path getMember() uses
- * everywhere else), looks up `vibeWorkspaces` by (userId, slug), and returns
- * the workspace's port. The endpoint that does the lookup is owned by the
- * provisioning service (HAP-1154); the contract is documented on
- * createHttpResolver below.
+ * everywhere else) and authorizes them, but the workspace is keyed by the
+ * SELECTED BRANCH (HAP-1164), looked up as `vibeWorkspaces` by (site, branch).
+ * The branch travels with the request (x-vibe-branch header / vibe_branch cookie);
+ * two members on the same branch resolve to the same port. The endpoint that does
+ * the lookup is owned by the provisioning service (HAP-1154); the contract is
+ * documented on createHttpResolver below.
  */
 
 export const DEFAULT_STAGING_PREFIX = 'staging.'
 
+// Header / cookie the editing surface (and the orchestrator) use to carry the
+// SELECTED BRANCH with a staging request (HAP-1164). The branch — not the session
+// identity — is what the resolver demuxes on, so it must travel with every
+// request. Header wins over cookie when both are present.
+export const BRANCH_HEADER = 'x-vibe-branch'
+export const BRANCH_COOKIE = 'vibe_branch'
+
+// Pure: pull the selected branch out of a request's headers (header first, then
+// the `vibe_branch` cookie). Returns '' when none is present so the resolver can
+// fall back to the site's configured default branch.
+export function parseBranchFromReq(req) {
+    const headerVal = req?.headers?.[BRANCH_HEADER]
+    if (headerVal) return String(Array.isArray(headerVal) ? headerVal[0] : headerVal).trim()
+
+    const cookieHeader = req?.headers?.cookie || ''
+    for (const pair of String(cookieHeader).split(';')) {
+        const idx = pair.indexOf('=')
+        if (idx === -1) continue
+        if (pair.slice(0, idx).trim() === BRANCH_COOKIE) {
+            try {
+                return decodeURIComponent(pair.slice(idx + 1).trim())
+            } catch {
+                return pair.slice(idx + 1).trim()
+            }
+        }
+    }
+    return ''
+}
+
 // Pure: does this request's Host header look like a staging request, and what
 // site slug does it resolve to?
 //
@@ -89,9 +120,13 @@ export async function resolveStagingTarget({ req, slug, resolve }) {
         }
     }
 
+    // The SELECTED BRANCH (HAP-1164) travels with the request and is what the
+    // resolver demuxes on. Absent → resolver falls back to the configured default.
+    const branch = parseBranchFromReq(req)
+
     let result
     try {
-        result = await resolve({ slug, cookieHeader, authHeader, req })
+        result = await resolve({ slug, branch, cookieHeader, authHeader, req })
     } catch (err) {
         return { error: 'resolver_error', status: 502, message: `Vibe staging resolver error: ${err?.message || err}` }
     }
@@ -117,13 +152,13 @@ export async function resolveStagingTarget({ req, slug, resolve }) {
  * Production resolver: calls Mango (running on the backend port colocated with
  * this proxy) at a small system endpoint that does identity + workspace lookup.
  *
- *   GET <resolverPath>?slug=<slug>
+ *   GET <resolverPath>?slug=<slug>[&branch=<branch>]
  *   forwards: Cookie, Authorization
  *
  *   200 { port: <int> }    workspace found, proxy to that port
  *   401                    no member could be identified
  *   403                    member identified, but not authorized for slug
- *   404                    no vibeWorkspaces record for (userId, slug)
+ *   404                    no vibeWorkspaces record for (site, branch)
  *   5xx / network error    surfaced as resolver_error
  *
  * The endpoint implementation lives with the provisioning service (HAP-1154)
@@ -146,9 +181,10 @@ export function createHttpResolver({
         throw new Error('createHttpResolver: http module with request() is required')
     }
 
-    return function resolve({ slug, cookieHeader, authHeader }) {
+    return function resolve({ slug, branch, cookieHeader, authHeader }) {
         return new Promise((resolvePromise) => {
-            const path = `${resolverPath}?slug=${encodeURIComponent(slug)}`
+            let path = `${resolverPath}?slug=${encodeURIComponent(slug)}`
+            if (branch) path += `&branch=${encodeURIComponent(branch)}`
             const headers = {}
             if (cookieHeader) headers.cookie = cookieHeader
             if (authHeader) headers.authorization = authHeader
@@ -229,3 +265,128 @@ export function createHttpResolver({
         })
     }
 }
+
+/**
+ * Standalone staging-gateway server factory (HAP-1165).
+ *
+ * Wraps parseStagingHost + resolveStagingTarget + createHttpResolver into a
+ * runnable HTTP server fronted by nginx on the droplet. Listens on a configured
+ * loopback port; nginx proxy_passes `staging-vibe.<site>` to it instead of to
+ * the shared `:7121` front, so per-branch isolation actually happens.
+ *
+ * Pure DI: `http` and `httpProxy` are injected so the module itself has no
+ * runtime imports and stays unit-testable with plain node fakes. The thin
+ * CLI entry `lib/staging-gateway.js` wires the real modules.
+ *
+ * Behavior:
+ *   - 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.
+ *   - Upgrade-time resolver failure → socket destroyed (Vite retries the WS).
+ *
+ * Returns { server, proxy, close() } — caller owns server.listen(port, host).
+ */
+export function createStagingGatewayServer({
+    http,
+    httpProxy,
+    stagingDomain,
+    stagingHostPrefix,
+    backendPort,
+    resolverPath,
+    timeoutMs,
+    onError,
+} = {}) {
+    if (!http || typeof http.createServer !== 'function') {
+        throw new Error('createStagingGatewayServer: http module with createServer() is required')
+    }
+    if (!httpProxy || typeof httpProxy.createProxyServer !== 'function') {
+        throw new Error('createStagingGatewayServer: httpProxy module with createProxyServer() is required')
+    }
+    if (!Number.isInteger(backendPort)) {
+        throw new Error('createStagingGatewayServer: backendPort (integer) is required')
+    }
+
+    const resolve = createHttpResolver({ backendPort, resolverPath, timeoutMs, http })
+    const proxy = httpProxy.createProxyServer({ ws: true, xfwd: true })
+
+    const log = (where, err, req) => {
+        if (typeof onError === 'function') onError(where, err, req)
+    }
+
+    proxy.on('error', (err, req, res) => {
+        log('proxy', err, req)
+        if (res && typeof res.writeHead === 'function' && !res.headersSent) {
+            res.writeHead(502, { 'Content-Type': 'text/plain; charset=utf-8' })
+            res.end(`Bad gateway: ${err?.message || err}`)
+        } else if (res && typeof res.destroy === 'function') {
+            // Upgrade path: `res` is a Socket — close it, browser retries.
+            try { res.destroy() } catch { /* noop */ }
+        }
+    })
+
+    const parseHostOpts = { stagingDomain, stagingHostPrefix }
+    function parseHost(req) {
+        return parseStagingHost(req?.headers?.host, parseHostOpts)
+    }
+
+    function sendError(res, status, message) {
+        if (!res || res.headersSent) return
+        res.writeHead(status, { 'Content-Type': 'text/plain; charset=utf-8' })
+        res.end(message)
+    }
+
+    async function handleRequest(req, res) {
+        const parsed = parseHost(req)
+        if (!parsed) {
+            sendError(res, 404, `Unknown host: ${req?.headers?.host || '(missing Host header)'}`)
+            return
+        }
+        const outcome = await resolveStagingTarget({ req, slug: parsed.slug, resolve })
+        if (outcome.error) {
+            sendError(res, outcome.status || 502, outcome.message || outcome.error)
+            return
+        }
+        proxy.web(req, res, { target: outcome.target })
+    }
+
+    async function handleUpgrade(req, socket, head) {
+        const parsed = parseHost(req)
+        if (!parsed) {
+            try { socket.destroy() } catch { /* noop */ }
+            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.
+            try { socket.destroy() } catch { /* noop */ }
+            return
+        }
+        proxy.ws(req, socket, head, { target: outcome.target })
+    }
+
+    const server = http.createServer((req, res) => {
+        handleRequest(req, res).catch((err) => {
+            log('request', err, req)
+            sendError(res, 502, `Staging gateway error: ${err?.message || err}`)
+        })
+    })
+
+    server.on('upgrade', (req, socket, head) => {
+        handleUpgrade(req, socket, head).catch((err) => {
+            log('upgrade', err, req)
+            try { socket.destroy() } catch { /* noop */ }
+        })
+    })
+
+    return {
+        server,
+        proxy,
+        close() {
+            return new Promise((res) => {
+                try { proxy.close(() => {}) } catch { /* noop */ }
+                server.close(() => res())
+            })
+        },
+    }
+}

package/lib/staging-gateway.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+/**
+ * Mango Vibe Staging Gateway (HAP-1165)
+ *
+ * Standalone server that fronts the multi-user staging editing surface. nginx
+ * proxy_passes the staging hostname (e.g. `staging-vibe.generations.org`) to
+ * this process on a loopback port; the gateway demuxes by selected branch
+ * (HAP-1164) into the right Vibe workspace's dev-server port, including the
+ * Vite HMR WebSocket upgrade.
+ *
+ * Configuration (env vars):
+ *   BACKEND_PORT    (required, int)  Mango port that owns /system/vibe/staging-resolve.
+ *   LISTEN_PORT     (default 7123, int)  Loopback port to bind.
+ *   LISTEN_HOST     (default 127.0.0.1)  Bind host — keep loopback so nginx fronts it.
+ *   STAGING_DOMAIN  (optional)  Exact staging hostname; when set, only that host
+ *                               (and `staging.*` prefix matches) are routed.
+ *   STAGING_HOST_PREFIX  (default "staging.")  Prefix fallback for slug demux.
+ *   RESOLVER_PATH   (default /system/vibe/staging-resolve)
+ *   RESOLVER_TIMEOUT_MS (default 2000, int)
+ *
+ * Usage (typical droplet pm2):
+ *   BACKEND_PORT=7122 LISTEN_PORT=7123 \
+ *   STAGING_DOMAIN=staging-vibe.generations.org \
+ *   node node_modules/mango-cms/lib/staging-gateway.js
+ */
+
+import http from 'http'
+import httpProxy from 'http-proxy'
+import { createStagingGatewayServer } from './devProxyGateway.js'
+
+function intEnv(name, fallback) {
+    const raw = process.env[name]
+    if (raw === undefined || raw === '') return fallback
+    const n = parseInt(raw, 10)
+    if (!Number.isInteger(n) || n <= 0) {
+        console.error(`[staging-gateway] ${name} must be a positive integer (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')
+    process.exit(1)
+}
+
+const LISTEN_PORT = intEnv('LISTEN_PORT', 7123)
+const LISTEN_HOST = process.env.LISTEN_HOST || '127.0.0.1'
+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 { server, close } = createStagingGatewayServer({
+    http,
+    httpProxy,
+    stagingDomain: STAGING_DOMAIN || undefined,
+    stagingHostPrefix: STAGING_HOST_PREFIX,
+    backendPort: BACKEND_PORT,
+    resolverPath: RESOLVER_PATH,
+    timeoutMs: RESOLVER_TIMEOUT_MS,
+    onError: (where, err) => {
+        console.error(`[staging-gateway] ${where} error: ${err?.message || err}`)
+    },
+})
+
+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})`)
+})
+
+function shutdown(signal) {
+    console.log(`[staging-gateway] ${signal} — closing server`)
+    close().then(() => process.exit(0)).catch(() => process.exit(1))
+    setTimeout(() => process.exit(1), 5000).unref()
+}
+process.on('SIGTERM', () => shutdown('SIGTERM'))
+process.on('SIGINT', () => shutdown('SIGINT'))

package/package.json

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