@hotmeshio/long-tail 0.4.16 → 0.4.18

package/build/adapters/express.js

@@ -117,6 +117,10 @@ class LTExpressAdapter {
         // Attach NATS WebSocket proxy (if configured)
         const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
         if (natsAdapter?.wsProxyTarget) {
+            // Store basePath so the settings endpoint can derive the correct wsUrl
+            if (this.basePath) {
+                natsAdapter.setWsProxyBasePath(this.basePath);
+            }
             (0, nats_ws_proxy_1.attachNatsWsProxy)(server, natsAdapter.wsProxyTarget, {
                 basePath: this.basePath,
                 onWsUrlDerived: (url) => {

package/build/api/settings.d.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage } from 'http';
 import type { LTApiResult } from '../types/sdk';
 /**
  * Return platform settings for the current deployment.
@@ -5,6 +6,7 @@ import type { LTApiResult } from '../types/sdk';
  * Includes telemetry configuration (trace URL), escalation claim duration
  * options, and event transport details (socket.io, NATS, or none).
  *
+ * @param req — the incoming HTTP request, used to derive NATS WS URL from headers when proxying
  * @returns `{ status: 200, data: { telemetry, escalation, events } }`
  */
-export declare function getSettings(): Promise<LTApiResult>;
+export declare function getSettings(req?: IncomingMessage): Promise<LTApiResult>;

package/build/api/settings.js

@@ -5,18 +5,39 @@ const telemetry_1 = require("../lib/telemetry");
 const events_1 = require("../lib/events");
 const nats_1 = require("../lib/events/nats");
 const socketio_1 = require("../lib/events/socketio");
+const nats_ws_proxy_1 = require("../lib/events/nats-ws-proxy");
 const config_1 = require("../modules/config");
 const defaults_1 = require("../modules/defaults");
 const llm_1 = require("../services/llm");
+/**
+ * Resolve the NATS WebSocket URL for the browser.
+ *
+ * Priority:
+ * 1. Explicit wsUrl on the adapter (set via config or auto-derived from a prior request)
+ * 2. When a wsProxy is configured, derive from the current request's headers
+ * 3. null — no NATS WS available
+ */
+function resolveNatsWsUrl(adapter, req) {
+    if (adapter.wsUrl)
+        return adapter.wsUrl;
+    if (adapter.wsProxyTarget && req) {
+        const derived = (0, nats_ws_proxy_1.deriveWsUrlFromRequest)(req, adapter.wsProxyBasePath);
+        // Cache for future requests and for the proxy's onWsUrlDerived
+        adapter.setWsUrl(derived);
+        return derived;
+    }
+    return null;
+}
 /**
  * Return platform settings for the current deployment.
  *
  * Includes telemetry configuration (trace URL), escalation claim duration
  * options, and event transport details (socket.io, NATS, or none).
  *
+ * @param req — the incoming HTTP request, used to derive NATS WS URL from headers when proxying
  * @returns `{ status: 200, data: { telemetry, escalation, events } }`
  */
-async function getSettings() {
+async function getSettings(req) {
     try {
         const hasSocketIO = !!events_1.eventRegistry.getAdapter(socketio_1.SocketIOEventAdapter);
         const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
@@ -37,7 +58,7 @@ async function getSettings() {
                 },
                 events: {
                     transport,
-                    natsWsUrl: natsAdapter?.wsUrl ?? null,
+                    natsWsUrl: natsAdapter ? resolveNatsWsUrl(natsAdapter, req) : null,
                 },
                 ai: {
                     enabled: (0, llm_1.hasLLMApiKey)(),

package/build/lib/events/nats-ws-proxy.d.ts

@@ -1,6 +1,15 @@
 import type { Server as HttpServer } from 'http';
 /** Default path for the NATS WebSocket proxy endpoint. */
 export declare const NATS_WS_PROXY_PATH = "/nats-ws";
+/**
+ * Derive the public NATS WebSocket URL from an HTTP request's headers.
+ *
+ * Respects `X-Forwarded-Proto` and `X-Forwarded-Host` so the correct
+ * `wss://` scheme is used behind TLS-terminating load balancers.
+ */
+export declare function deriveWsUrlFromRequest(req: {
+    headers: Record<string, string | string[] | undefined>;
+}, basePath?: string): string;
 /**
  * Attach a WebSocket proxy to an HTTP server that bridges browser
  * connections to an internal NATS WebSocket endpoint.

package/build/lib/events/nats-ws-proxy.js

@@ -1,11 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NATS_WS_PROXY_PATH = void 0;
+exports.deriveWsUrlFromRequest = deriveWsUrlFromRequest;
 exports.attachNatsWsProxy = attachNatsWsProxy;
 const ws_1 = require("ws");
 const logger_1 = require("../logger");
 /** Default path for the NATS WebSocket proxy endpoint. */
 exports.NATS_WS_PROXY_PATH = '/nats-ws';
+/**
+ * Derive the public NATS WebSocket URL from an HTTP request's headers.
+ *
+ * Respects `X-Forwarded-Proto` and `X-Forwarded-Host` so the correct
+ * `wss://` scheme is used behind TLS-terminating load balancers.
+ */
+function deriveWsUrlFromRequest(req, basePath = '') {
+    const proto = req.headers['x-forwarded-proto'] || 'ws';
+    const scheme = proto === 'https' ? 'wss' : 'ws';
+    const host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
+    return `${scheme}://${host}${basePath}${exports.NATS_WS_PROXY_PATH}`;
+}
 /**
  * Attach a WebSocket proxy to an HTTP server that bridges browser
  * connections to an internal NATS WebSocket endpoint.
@@ -28,10 +41,7 @@ function attachNatsWsProxy(server, target, options = {}) {
             return;
         // Derive the public wsUrl from the first request's headers
         if (!derived && options.onWsUrlDerived) {
-            const proto = req.headers['x-forwarded-proto'] || 'ws';
-            const scheme = proto === 'https' ? 'wss' : 'ws';
-            const host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
-            options.onWsUrlDerived(`${scheme}://${host}${proxyPath}`);
+            options.onWsUrlDerived(deriveWsUrlFromRequest(req, basePath));
             derived = true;
         }
         wss.handleUpgrade(req, socket, head, (clientWs) => {

package/build/lib/events/nats.d.ts

@@ -25,6 +25,7 @@ export declare class NatsEventAdapter implements LTEventAdapter {
     private url;
     private _wsUrl;
     private _wsProxyTarget;
+    private _wsProxyBasePath;
     private subjectPrefix;
     private token?;
     private originId;
@@ -46,6 +47,10 @@ export declare class NatsEventAdapter implements LTEventAdapter {
     setWsUrl(url: string): void;
     /** Internal NATS WS target for the proxy to bridge to (e.g. ws://nats:9222). */
     get wsProxyTarget(): string | null;
+    /** BasePath the proxy is mounted at (e.g. /longtail). Set by LTExpressAdapter. */
+    get wsProxyBasePath(): string;
+    /** Set the proxy basePath (called by LTExpressAdapter.attachServer). */
+    setWsProxyBasePath(basePath: string): void;
     /** NATS auth token for browser connections. */
     get authToken(): string | null;
     /**

package/build/lib/events/nats.js

@@ -30,6 +30,7 @@ class NatsEventAdapter {
     constructor(options) {
         this.nc = null;
         this.sub = null;
+        this._wsProxyBasePath = '';
         this.originId = (0, crypto_1.randomUUID)();
         this.callbackAdapter = null;
         this.url = options?.url || config_1.config.NATS_URL;
@@ -54,6 +55,14 @@ class NatsEventAdapter {
     get wsProxyTarget() {
         return this._wsProxyTarget;
     }
+    /** BasePath the proxy is mounted at (e.g. /longtail). Set by LTExpressAdapter. */
+    get wsProxyBasePath() {
+        return this._wsProxyBasePath;
+    }
+    /** Set the proxy basePath (called by LTExpressAdapter.attachServer). */
+    setWsProxyBasePath(basePath) {
+        this._wsProxyBasePath = basePath;
+    }
     /** NATS auth token for browser connections. */
     get authToken() {
         return this.token || null;

package/build/routes/nats-credentials.js

@@ -3,19 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const events_1 = require("../lib/events");
 const nats_1 = require("../lib/events/nats");
+const nats_ws_proxy_1 = require("../lib/events/nats-ws-proxy");
 const router = (0, express_1.Router)();
 /**
  * GET /api/nats-credentials
  * Returns NATS WebSocket URL and auth token.
  * Mounted behind requireAuth — only authenticated users receive the token.
  */
-router.get('/', async (_req, res) => {
+router.get('/', async (req, res) => {
     const natsAdapter = events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
     if (!natsAdapter) {
         return res.json({ natsWsUrl: null, natsToken: null });
     }
+    // Derive wsUrl from request headers when proxy is active but no URL cached yet
+    let wsUrl = natsAdapter.wsUrl;
+    if (!wsUrl && natsAdapter.wsProxyTarget) {
+        wsUrl = (0, nats_ws_proxy_1.deriveWsUrlFromRequest)(req, natsAdapter.wsProxyBasePath);
+        natsAdapter.setWsUrl(wsUrl);
+    }
     res.json({
-        natsWsUrl: natsAdapter.wsUrl,
+        natsWsUrl: wsUrl,
         natsToken: natsAdapter.authToken,
     });
 });

package/build/routes/settings.js

@@ -40,8 +40,8 @@ const router = (0, express_1.Router)();
  * GET /api/settings
  * Returns frontend-relevant configuration (no secrets).
  */
-router.get('/', async (_req, res) => {
-    const result = await api.getSettings();
+router.get('/', async (req, res) => {
+    const result = await api.getSettings(req);
     res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/long-tail",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "description": "Long Tail Workflows — Durable AI workflows with human-in-the-loop escalation. Powered by PostgreSQL.",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",