@undefineds.co/xpod 0.4.10 → 0.4.12

package/dist/runtime/Proxy.js

@@ -9,6 +9,7 @@ const http_1 = __importDefault(require("http"));
 const global_logger_factory_1 = require("global-logger-factory");
 const NodeRuntimeHost_1 = require("./host/node/NodeRuntimeHost");
 const GatewayAdminProxyAuth_1 = require("./GatewayAdminProxyAuth");
+const BunNativeUpgradeRelay_1 = require("./upgrade/BunNativeUpgradeRelay");
 // CORS configuration matching CSS CorsHandler defaults
 const CORS_CONFIG = {
     methods: ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE'],
@@ -25,6 +26,10 @@ const CORS_CONFIG = {
         'WAC-Allow', 'Www-Authenticate', 'X-Request-Id',
     ],
 };
+/**
+ * Grace period (ms) for the listener to report a clean close; see `closeServer`.
+ */
+const SERVER_CLOSE_GRACE_MS = 2_000;
 const SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER = 'x-xpod-canonical-url';
 const SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER = 'x-xpod-canonical-origin';
 const SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER = 'x-xpod-canonical-host';
@@ -40,6 +45,8 @@ class GatewayProxy {
         this.supervisor = supervisor;
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.targets = {};
+        /** Sockets created by `upgrade` events, dropped on shutdown. */
+        this.upgradeSockets = new Set();
         this.runtimeHost = options.runtimeHost ?? NodeRuntimeHost_1.nodeRuntimeHost;
         this.listenEndpoint = options.listenEndpoint ?? this.runtimeHost.createListenEndpoint({
             port,
@@ -81,20 +88,52 @@ class GatewayProxy {
             });
         });
         this.server = http_1.default.createServer(this.handleRequest.bind(this));
+        if (options.nativeUpgradeRelay ?? isBunRuntime()) {
+            this.nativeUpgradeRelay = new BunNativeUpgradeRelay_1.BunNativeUpgradeRelay({
+                logger: this.logger,
+                fallback: (req, socket, head, target) => this.relayUpgradeWithHttpProxy(req, socket, head, target),
+            });
+        }
         this.server.on('upgrade', (req, socket, head) => {
-            const url = req.url ?? '/';
-            // Route /ws/* and device notification WebSocket connections to API server
-            if ((url.startsWith('/ws/') || url.startsWith('/v1/notifications/ws')) && this.targets.api) {
-                this.proxy.ws(req, socket, head, { target: this.toProxyTarget(this.targets.api) });
-            }
-            else if (this.targets.css) {
-                this.proxy.ws(req, socket, head, { target: this.toProxyTarget(this.targets.css) });
-            }
-            else {
+            this.trackUpgradeSocket(socket);
+            const target = this.resolveUpgradeTarget(req.url ?? '/');
+            if (!target) {
                 socket.destroy();
+                return;
             }
+            if (this.nativeUpgradeRelay) {
+                this.nativeUpgradeRelay.handle(req, socket, head, target);
+                return;
+            }
+            this.relayUpgradeWithHttpProxy(req, socket, head, target);
+        });
+    }
+    /**
+     * Upgraded sockets outlive the HTTP request that created them; they are
+     * tracked so shutdown can drop them instead of waiting for a long lived
+     * notification channel to end on its own.
+     */
+    trackUpgradeSocket(socket) {
+        this.upgradeSockets.add(socket);
+        socket.once('close', () => {
+            this.upgradeSockets.delete(socket);
         });
     }
+    /**
+     * Picks the internal service that owns an upgrade path.
+     *
+     * `/ws/*` and the device notification multiplex live on the API server; every
+     * other upgrade (Solid notification channels, edge node tunnels) goes to CSS.
+     */
+    resolveUpgradeTarget(url) {
+        if ((url.startsWith('/ws/') || url.startsWith('/v1/notifications/ws')) && this.targets.api) {
+            return this.targets.api;
+        }
+        return this.targets.css;
+    }
+    relayUpgradeWithHttpProxy(req, socket, head, target) {
+        this.proxy.ws(req, socket, head, { target: this.toProxyTarget(target) });
+    }
     setTargets(targets) {
         this.targets = {
             css: this.normalizeTarget(targets.css),
@@ -105,13 +144,43 @@ class GatewayProxy {
         await this.runtimeHost.listen(this.server, this.listenEndpoint);
         this.logger.info(`Listening on ${this.runtimeHost.formatListenEndpoint(this.listenEndpoint)}`);
     }
-    stop() {
-        return new Promise((resolve, reject) => {
-            this.proxy.close();
-            this.runtimeHost.close(this.server, this.listenEndpoint).then(() => {
-                resolve();
-            }, reject);
-        });
+    async stop() {
+        this.nativeUpgradeRelay?.close();
+        // Upgraded connections never end on their own, so `server.close()` would
+        // otherwise wait for an idle notification channel to time out.
+        for (const socket of [...this.upgradeSockets]) {
+            socket.destroy();
+        }
+        this.upgradeSockets.clear();
+        this.proxy.close();
+        await this.closeServer();
+    }
+    /**
+     * Closes the listener with a bounded wait.
+     *
+     * The listening socket stops accepting as soon as `close()` is called, but
+     * the callback waits for every connection to end. Node keeps upgraded sockets
+     * counted until they are destroyed (done above); Bun additionally never calls
+     * back once a WebSocket was closed from the server side
+     * (oven-sh/bun#28396), so waiting forever would block gateway restarts.
+     */
+    async closeServer() {
+        const closing = this.runtimeHost.close(this.server, this.listenEndpoint);
+        let timer;
+        const timedOut = await Promise.race([
+            closing.then(() => false),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(true), SERVER_CLOSE_GRACE_MS);
+                timer.unref?.();
+            }),
+        ]);
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (timedOut) {
+            this.logger.warn(`Gateway server did not report a clean close within ${SERVER_CLOSE_GRACE_MS}ms; continuing shutdown`);
+            void closing.catch(() => undefined);
+        }
     }
     handleRequest(req, res) {
         const url = req.url ?? '/';
@@ -583,4 +652,7 @@ class GatewayProxy {
     }
 }
 exports.GatewayProxy = GatewayProxy;
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
 //# sourceMappingURL=Proxy.js.map

package/dist/runtime/bootstrap.js

@@ -13,6 +13,7 @@ const global_logger_factory_1 = require("global-logger-factory");
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
 const ConfigurableLoggerFactory_1 = require("../logging/ConfigurableLoggerFactory");
+const log_file_1 = require("../logging/log-file");
 const package_root_1 = require("./package-root");
 const oidc_issuer_1 = require("./oidc-issuer");
 const NodeRuntimePlatform_1 = require("./platform/node/NodeRuntimePlatform");
@@ -402,7 +403,7 @@ function rewriteConfigImport(sourceConfigPath, importValue, outputDir, platform,
 }
 function initRuntimeLogger(level, platform = NodeRuntimePlatform_1.nodeRuntimePlatform) {
     const loggerFactory = new ConfigurableLoggerFactory_1.ConfigurableLoggerFactory(level, {
-        fileName: platform.joinPath(platform.cwd(), 'logs/xpod-%DATE%.log'),
+        fileName: platform.joinPath(platform.cwd(), log_file_1.LOG_FILE_PATTERN),
         showLocation: true,
     });
     (0, global_logger_factory_1.setGlobalLoggerFactory)(loggerFactory);

package/dist/runtime/upgrade/BunNativeUpgradeRelay.d.ts

@@ -0,0 +1,116 @@
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+/**
+ * WebSocket upgrade relay for runtimes whose HTTP server cannot hand the raw
+ * upgraded socket back to JavaScript.
+ *
+ * Bun's `node:http` server is one of them: the socket passed to the `'upgrade'`
+ * event never delivers client bytes (`'data'` does not fire) and its
+ * `socket.write()` never reaches the peer, so `http-proxy`'s WebSocket pass
+ * drops the `101` response and then the whole frame stream
+ * (oven-sh/bun#9882, oven-sh/bun#18945, oven-sh/bun#28396). The internal
+ * services keep working because they use `ws`, which Bun implements natively.
+ *
+ * The relay therefore terminates the client side with that same native
+ * WebSocket support and speaks the upstream hop itself over a raw TCP/Unix
+ * socket. The upstream side stays byte-accurate — including non-101 rejections
+ * and Unix socket targets — while `WebSocketFrames` bridges messages to frames.
+ */
+export interface NativeUpgradeTarget {
+    url?: string;
+    socketPath?: string;
+}
+/** Logging surface of the relay (satisfied by `getLoggerFor`). */
+export interface RelayLogger {
+    debug(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+/** Subset of the `ws` module surface used by the relay. */
+export interface RelayWebSocket {
+    send(data: Buffer, options?: {
+        binary?: boolean;
+    }): void;
+    close(code?: number, reason?: string): void;
+    on(event: 'message', listener: (data: Buffer | ArrayBuffer | Buffer[] | string, isBinary: boolean) => void): void;
+    on(event: 'close', listener: (code: number, reason: Buffer) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+}
+export interface RelayWebSocketServer {
+    handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer, callback: (client: RelayWebSocket) => void): void;
+}
+export interface RelayWebSocketModule {
+    WebSocketServer: new (options: Record<string, unknown>) => RelayWebSocketServer;
+}
+/** Loads the runtime's `ws` implementation; `undefined` when it is unavailable. */
+export type WebSocketModuleLoader = () => Promise<RelayWebSocketModule | undefined>;
+export interface BunNativeUpgradeRelayOptions {
+    logger: RelayLogger;
+    /** Relays the upgrade the classic way when native WebSocket support is unavailable. */
+    fallback(req: IncomingMessage, socket: Duplex, head: Buffer, target: NativeUpgradeTarget): void;
+    /** Test seam: replaces the runtime `ws` import. */
+    loadWebSocketModule?: WebSocketModuleLoader;
+    handshakeTimeoutMs?: number;
+    closeGraceMs?: number;
+    maxHandshakeBytes?: number;
+}
+export interface RelayConnectionDependencies {
+    logger: RelayLogger;
+    onClosed(connection: NativeUpgradeConnection): void;
+    handshakeTimeoutMs: number;
+    closeGraceMs: number;
+    maxHandshakeBytes: number;
+}
+export declare class BunNativeUpgradeRelay {
+    private readonly options;
+    private readonly connections;
+    private readonly loadWebSocketModule;
+    private readonly handshakeTimeoutMs;
+    private readonly closeGraceMs;
+    private readonly maxHandshakeBytes;
+    private modulePromise?;
+    private moduleReported;
+    constructor(options: BunNativeUpgradeRelayOptions);
+    handle(req: IncomingMessage, socket: Duplex, head: Buffer, target: NativeUpgradeTarget): void;
+    /** Terminates every relayed connection (gateway shutdown/restart). */
+    close(): void;
+    private start;
+    private webSocketModule;
+}
+export declare class NativeUpgradeConnection {
+    private readonly module;
+    private readonly deps;
+    private upstream?;
+    private clientSocket?;
+    private client?;
+    private parser?;
+    private protocol;
+    private handshakeBuffer;
+    private handshakeTimer?;
+    private handshakeListener?;
+    private closeTimer?;
+    private errorTimer?;
+    private state;
+    constructor(module: RelayWebSocketModule, deps: RelayConnectionDependencies);
+    start(req: IncomingMessage, socket: Duplex, head: Buffer, target: NativeUpgradeTarget): void;
+    /** Closes the relayed connection as part of gateway shutdown. */
+    shutdown(): void;
+    private connectUpstream;
+    private onUpstreamHandshakeData;
+    /**
+     * Relays a non-101 upstream answer verbatim so clients observe the real
+     * status (401 for an expired ticket, 404 for an unknown channel, ...).
+     */
+    private relayRejection;
+    private closeRejectedClient;
+    private createFrameParser;
+    private upgradeClient;
+    private forwardClientMessage;
+    private onClientClose;
+    /** Waits briefly for the upstream close handshake before dropping the socket. */
+    private scheduleUpstreamClose;
+    private fail;
+    private destroy;
+    private clearHandshakeTimer;
+    private finish;
+}