@junctionpanel/server 0.1.16

package/dist/server/server/websocket-server.js

@@ -0,0 +1,742 @@
+import { WebSocketServer as WebSocketServer_WS } from "ws";
+import { hostname as getHostname } from "node:os";
+import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
+import { asUint8Array, decodeBinaryMuxFrame, encodeBinaryMuxFrame, } from "../shared/binary-mux.js";
+import { isHostAllowed } from "./allowed-hosts.js";
+import { Session } from "./session.js";
+import { computeShouldNotifyClient, } from "./agent-attention-policy.js";
+import { buildAgentAttentionNotificationPayload, findLatestAssistantMessageFromTimeline, findLatestPermissionRequest, } from "../shared/agent-attention-notification.js";
+function bufferFromWsData(data) {
+    if (typeof data === "string")
+        return Buffer.from(data, "utf8");
+    if (Array.isArray(data)) {
+        return Buffer.concat(data.map((item) => Buffer.isBuffer(item) ? item : Buffer.from(item)));
+    }
+    if (Buffer.isBuffer(data))
+        return data;
+    return Buffer.from(data);
+}
+const EXTERNAL_SESSION_DISCONNECT_GRACE_MS = 90000;
+const HELLO_TIMEOUT_MS = 15000;
+const WS_CLOSE_HELLO_TIMEOUT = 4001;
+const WS_CLOSE_INVALID_HELLO = 4002;
+const WS_CLOSE_INCOMPATIBLE_PROTOCOL = 4003;
+const WS_CLOSE_AUTH_REQUIRED = 4004;
+const WS_PROTOCOL_VERSION = 1;
+export class MissingDaemonVersionError extends Error {
+    constructor() {
+        super("WebSocketServer requires a non-empty daemonVersion.");
+        this.name = "MissingDaemonVersionError";
+    }
+}
+/**
+ * WebSocket server that only accepts sockets + parses/forwards messages to the session layer.
+ */
+export class WebSocketServer {
+    constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, junctionHome, createAgentMcpTransport, wsConfig, terminalManager, agentProviderRuntimeSettings, daemonVersion, onLifecycleIntent, jwtValidator) {
+        this.pendingConnections = new Map();
+        this.sessions = new Map();
+        this.externalSessionsByKey = new Map();
+        this.ACTIVITY_THRESHOLD_MS = 120000;
+        this.logger = logger.child({ module: "websocket-server" });
+        this.serverId = serverId;
+        if (typeof daemonVersion !== "string" || daemonVersion.trim().length === 0) {
+            throw new MissingDaemonVersionError();
+        }
+        this.daemonVersion = daemonVersion.trim();
+        this.agentManager = agentManager;
+        this.agentStorage = agentStorage;
+        this.downloadTokenStore = downloadTokenStore;
+        this.junctionHome = junctionHome;
+        this.createAgentMcpTransport = createAgentMcpTransport;
+        this.terminalManager = terminalManager ?? null;
+        this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
+        this.onLifecycleIntent = onLifecycleIntent ?? null;
+        this.jwtValidator = jwtValidator ?? null;
+        this.agentManager.setAgentAttentionCallback((params) => {
+            this.broadcastAgentAttention(params);
+        });
+        const { allowedOrigins, allowedHosts } = wsConfig;
+        this.wss = new WebSocketServer_WS({
+            server,
+            path: "/ws",
+            verifyClient: ({ req }, callback) => {
+                const requestMetadata = extractSocketRequestMetadata(req);
+                const origin = requestMetadata.origin;
+                const requestHost = requestMetadata.host ?? null;
+                if (requestHost && !isHostAllowed(requestHost, allowedHosts)) {
+                    this.logger.warn({ ...requestMetadata, host: requestHost }, "Rejected connection from disallowed host");
+                    callback(false, 403, "Host not allowed");
+                    return;
+                }
+                const sameOrigin = !!origin &&
+                    !!requestHost &&
+                    (origin === `http://${requestHost}` || origin === `https://${requestHost}`);
+                if (!origin || allowedOrigins.has(origin) || sameOrigin) {
+                    callback(true);
+                }
+                else {
+                    this.logger.warn({ ...requestMetadata, origin }, "Rejected connection from origin");
+                    callback(false, 403, "Origin not allowed");
+                }
+            },
+        });
+        this.wss.on("connection", (ws, request) => {
+            void this.attachSocket(ws, request);
+        });
+        this.logger.info("WebSocket server initialized on /ws");
+    }
+    broadcast(message) {
+        const payload = JSON.stringify(message);
+        for (const ws of this.sessions.keys()) {
+            // WebSocket.OPEN = 1
+            if (ws.readyState === 1) {
+                ws.send(payload);
+            }
+        }
+    }
+    async attachExternalSocket(ws, metadata) {
+        await this.attachSocket(ws, undefined, metadata);
+    }
+    async close() {
+        const uniqueConnections = new Set([
+            ...this.sessions.values(),
+            ...this.externalSessionsByKey.values(),
+        ]);
+        const pendingSockets = new Set(this.pendingConnections.keys());
+        for (const pending of this.pendingConnections.values()) {
+            if (pending.helloTimeout) {
+                clearTimeout(pending.helloTimeout);
+                pending.helloTimeout = null;
+            }
+        }
+        const cleanupPromises = [];
+        for (const connection of uniqueConnections) {
+            if (connection.externalDisconnectCleanupTimeout) {
+                clearTimeout(connection.externalDisconnectCleanupTimeout);
+                connection.externalDisconnectCleanupTimeout = null;
+            }
+            cleanupPromises.push(connection.session.cleanup());
+            for (const ws of connection.sockets) {
+                cleanupPromises.push(new Promise((resolve) => {
+                    // WebSocket.CLOSED = 3
+                    if (ws.readyState === 3) {
+                        resolve();
+                        return;
+                    }
+                    ws.once("close", () => resolve());
+                    ws.close();
+                }));
+            }
+        }
+        for (const ws of pendingSockets) {
+            cleanupPromises.push(new Promise((resolve) => {
+                if (ws.readyState === 3) {
+                    resolve();
+                    return;
+                }
+                ws.once("close", () => resolve());
+                ws.close();
+            }));
+        }
+        await Promise.all(cleanupPromises);
+        this.pendingConnections.clear();
+        this.sessions.clear();
+        this.externalSessionsByKey.clear();
+        this.wss.close();
+    }
+    sendToClient(ws, message) {
+        // WebSocket.OPEN = 1
+        if (ws.readyState === 1) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    sendBinaryToClient(ws, frame) {
+        if (ws.readyState !== 1) {
+            return;
+        }
+        ws.send(encodeBinaryMuxFrame(frame));
+    }
+    sendToConnection(connection, message) {
+        for (const ws of connection.sockets) {
+            this.sendToClient(ws, message);
+        }
+    }
+    sendBinaryToConnection(connection, frame) {
+        for (const ws of connection.sockets) {
+            this.sendBinaryToClient(ws, frame);
+        }
+    }
+    async attachSocket(ws, request, metadata) {
+        const requestMetadata = extractSocketRequestMetadata(request);
+        const connectionLoggerFields = {
+            transport: metadata?.transport === "relay" ? "relay" : "direct",
+        };
+        if (requestMetadata.host) {
+            connectionLoggerFields.host = requestMetadata.host;
+        }
+        if (requestMetadata.origin) {
+            connectionLoggerFields.origin = requestMetadata.origin;
+        }
+        if (requestMetadata.userAgent) {
+            connectionLoggerFields.userAgent = requestMetadata.userAgent;
+        }
+        if (requestMetadata.remoteAddress) {
+            connectionLoggerFields.remoteAddress = requestMetadata.remoteAddress;
+        }
+        const connectionLogger = this.logger.child(connectionLoggerFields);
+        const pending = {
+            connectionLogger,
+            helloTimeout: null,
+        };
+        const timeout = setTimeout(() => {
+            if (this.pendingConnections.get(ws) !== pending) {
+                return;
+            }
+            pending.helloTimeout = null;
+            this.pendingConnections.delete(ws);
+            pending.connectionLogger.warn({ timeoutMs: HELLO_TIMEOUT_MS }, "Closing connection due to missing hello");
+            try {
+                ws.close(WS_CLOSE_HELLO_TIMEOUT, "Hello timeout");
+            }
+            catch {
+                // ignore close errors
+            }
+        }, HELLO_TIMEOUT_MS);
+        pending.helloTimeout = timeout;
+        timeout.unref?.();
+        this.pendingConnections.set(ws, pending);
+        this.bindSocketHandlers(ws);
+        pending.connectionLogger.trace({
+            totalPendingConnections: this.pendingConnections.size,
+        }, "Client connected; awaiting hello");
+    }
+    createSessionConnection(params) {
+        const { ws, clientId, userId, connectionLogger } = params;
+        let connection = null;
+        const session = new Session({
+            clientId,
+            userId,
+            onMessage: (msg) => {
+                if (!connection) {
+                    return;
+                }
+                this.sendToConnection(connection, wrapSessionMessage(msg));
+            },
+            onBinaryMessage: (frame) => {
+                if (!connection) {
+                    return;
+                }
+                this.sendBinaryToConnection(connection, frame);
+            },
+            onLifecycleIntent: (intent) => {
+                this.onLifecycleIntent?.(intent);
+            },
+            logger: connectionLogger.child({ module: "session" }),
+            downloadTokenStore: this.downloadTokenStore,
+            junctionHome: this.junctionHome,
+            agentManager: this.agentManager,
+            agentStorage: this.agentStorage,
+            createAgentMcpTransport: this.createAgentMcpTransport,
+            terminalManager: this.terminalManager,
+            agentProviderRuntimeSettings: this.agentProviderRuntimeSettings,
+        });
+        connection = {
+            session,
+            clientId,
+            connectionLogger,
+            sockets: new Set([ws]),
+            externalDisconnectCleanupTimeout: null,
+        };
+        return connection;
+    }
+    clearPendingConnection(ws) {
+        const pending = this.pendingConnections.get(ws);
+        if (!pending) {
+            return null;
+        }
+        if (pending.helloTimeout) {
+            clearTimeout(pending.helloTimeout);
+            pending.helloTimeout = null;
+        }
+        this.pendingConnections.delete(ws);
+        return pending;
+    }
+    buildWelcomeMessage(params) {
+        return {
+            type: "welcome",
+            serverId: this.serverId,
+            hostname: getHostname(),
+            version: this.daemonVersion,
+            resumed: params.resumed,
+        };
+    }
+    handleHello(params) {
+        const { ws, message, pending } = params;
+        if (message.protocolVersion !== WS_PROTOCOL_VERSION) {
+            this.clearPendingConnection(ws);
+            pending.connectionLogger.warn({
+                receivedProtocolVersion: message.protocolVersion,
+                expectedProtocolVersion: WS_PROTOCOL_VERSION,
+            }, "Rejected hello due to protocol version mismatch");
+            try {
+                ws.close(WS_CLOSE_INCOMPATIBLE_PROTOCOL, "Incompatible protocol version");
+            }
+            catch {
+                // ignore close errors
+            }
+            return;
+        }
+        const clientId = message.clientId.trim();
+        if (clientId.length === 0) {
+            this.clearPendingConnection(ws);
+            pending.connectionLogger.warn("Rejected hello with empty clientId");
+            try {
+                ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
+            }
+            catch {
+                // ignore close errors
+            }
+            return;
+        }
+        // Validate JWT if auth is enabled
+        let userId;
+        if (this.jwtValidator) {
+            if (!message.token) {
+                pending.connectionLogger.warn("Rejected hello: authentication required but no token provided");
+                try {
+                    ws.close(WS_CLOSE_AUTH_REQUIRED, "Authentication required");
+                }
+                catch {
+                    // ignore close errors
+                }
+                return;
+            }
+            const payload = this.jwtValidator(message.token);
+            if (!payload) {
+                pending.connectionLogger.warn("Rejected hello: invalid or expired token");
+                try {
+                    ws.close(WS_CLOSE_AUTH_REQUIRED, "Invalid token");
+                }
+                catch {
+                    // ignore close errors
+                }
+                return;
+            }
+            userId = payload.sub;
+        }
+        this.clearPendingConnection(ws);
+        const existing = this.externalSessionsByKey.get(clientId);
+        if (existing) {
+            if (existing.externalDisconnectCleanupTimeout) {
+                clearTimeout(existing.externalDisconnectCleanupTimeout);
+                existing.externalDisconnectCleanupTimeout = null;
+            }
+            existing.sockets.add(ws);
+            this.sessions.set(ws, existing);
+            this.sendToClient(ws, this.buildWelcomeMessage({ resumed: true }));
+            existing.connectionLogger.trace({
+                clientId,
+                resumed: true,
+                totalSessions: this.sessions.size,
+            }, "Client connected via hello");
+            return;
+        }
+        const connectionLogger = pending.connectionLogger.child({ clientId });
+        const connection = this.createSessionConnection({
+            ws,
+            clientId,
+            userId,
+            connectionLogger,
+        });
+        this.sessions.set(ws, connection);
+        this.externalSessionsByKey.set(clientId, connection);
+        this.sendToClient(ws, this.buildWelcomeMessage({ resumed: false }));
+        connection.connectionLogger.trace({
+            clientId,
+            resumed: false,
+            totalSessions: this.sessions.size,
+        }, "Client connected via hello");
+    }
+    bindSocketHandlers(ws) {
+        ws.on("message", (data) => {
+            void this.handleRawMessage(ws, data);
+        });
+        ws.on("close", async (code, reason) => {
+            await this.detachSocket(ws, {
+                code: typeof code === "number" ? code : undefined,
+                reason,
+            });
+        });
+        ws.on("error", async (error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            const active = this.sessions.get(ws);
+            const pending = this.pendingConnections.get(ws);
+            const log = active?.connectionLogger ?? pending?.connectionLogger ?? this.logger;
+            log.error({ err }, "Client error");
+            await this.detachSocket(ws, { error: err });
+        });
+    }
+    async detachSocket(ws, details) {
+        const pending = this.clearPendingConnection(ws);
+        if (pending) {
+            pending.connectionLogger.trace({
+                code: details.code,
+                reason: stringifyCloseReason(details.reason),
+            }, "Pending client disconnected");
+            return;
+        }
+        const connection = this.sessions.get(ws);
+        if (!connection) {
+            return;
+        }
+        this.sessions.delete(ws);
+        connection.sockets.delete(ws);
+        if (connection.sockets.size === 0) {
+            if (connection.externalDisconnectCleanupTimeout) {
+                clearTimeout(connection.externalDisconnectCleanupTimeout);
+            }
+            const timeout = setTimeout(() => {
+                if (connection.externalDisconnectCleanupTimeout !== timeout) {
+                    return;
+                }
+                connection.externalDisconnectCleanupTimeout = null;
+                void this.cleanupConnection(connection, "Client disconnected (grace timeout)");
+            }, EXTERNAL_SESSION_DISCONNECT_GRACE_MS);
+            connection.externalDisconnectCleanupTimeout = timeout;
+            connection.connectionLogger.trace({
+                clientId: connection.clientId,
+                code: details.code,
+                reason: stringifyCloseReason(details.reason),
+                reconnectGraceMs: EXTERNAL_SESSION_DISCONNECT_GRACE_MS,
+            }, "Client disconnected; waiting for reconnect");
+            return;
+        }
+        if (connection.sockets.size > 0) {
+            connection.connectionLogger.trace({
+                clientId: connection.clientId,
+                remainingSockets: connection.sockets.size,
+                code: details.code,
+                reason: stringifyCloseReason(details.reason),
+            }, "Client socket disconnected; session remains attached");
+            return;
+        }
+        await this.cleanupConnection(connection, "Client disconnected");
+    }
+    async cleanupConnection(connection, logMessage) {
+        if (connection.externalDisconnectCleanupTimeout) {
+            clearTimeout(connection.externalDisconnectCleanupTimeout);
+            connection.externalDisconnectCleanupTimeout = null;
+        }
+        for (const socket of connection.sockets) {
+            this.sessions.delete(socket);
+        }
+        connection.sockets.clear();
+        const existing = this.externalSessionsByKey.get(connection.clientId);
+        if (existing === connection) {
+            this.externalSessionsByKey.delete(connection.clientId);
+        }
+        connection.connectionLogger.trace({ clientId: connection.clientId, totalSessions: this.sessions.size }, logMessage);
+        await connection.session.cleanup();
+    }
+    async handleRawMessage(ws, data) {
+        const activeConnection = this.sessions.get(ws);
+        const pendingConnection = this.pendingConnections.get(ws);
+        const log = activeConnection?.connectionLogger ?? pendingConnection?.connectionLogger ?? this.logger;
+        try {
+            const buffer = bufferFromWsData(data);
+            const asBytes = asUint8Array(buffer);
+            if (asBytes) {
+                const frame = decodeBinaryMuxFrame(asBytes);
+                if (frame) {
+                    if (!activeConnection) {
+                        log.warn("Rejected binary frame before hello");
+                        this.clearPendingConnection(ws);
+                        try {
+                            ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
+                        }
+                        catch {
+                            // ignore close errors
+                        }
+                        return;
+                    }
+                    activeConnection.session.handleBinaryFrame(frame);
+                    return;
+                }
+            }
+            const parsed = JSON.parse(buffer.toString());
+            const parsedMessage = WSInboundMessageSchema.safeParse(parsed);
+            if (!parsedMessage.success) {
+                if (pendingConnection) {
+                    pendingConnection.connectionLogger.warn({
+                        error: parsedMessage.error.message,
+                    }, "Rejected pending message before hello");
+                    this.clearPendingConnection(ws);
+                    try {
+                        ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
+                    }
+                    catch {
+                        // ignore close errors
+                    }
+                    return;
+                }
+                const requestInfo = extractRequestInfoFromUnknownWsInbound(parsed);
+                const isUnknownSchema = requestInfo?.requestId != null &&
+                    typeof parsed === "object" &&
+                    parsed != null &&
+                    "type" in parsed &&
+                    parsed.type === "session";
+                log.warn({
+                    clientId: activeConnection?.clientId,
+                    requestId: requestInfo?.requestId,
+                    requestType: requestInfo?.requestType,
+                    error: parsedMessage.error.message,
+                }, "WS inbound message validation failed");
+                if (requestInfo) {
+                    this.sendToClient(ws, wrapSessionMessage({
+                        type: "rpc_error",
+                        payload: {
+                            requestId: requestInfo.requestId,
+                            requestType: requestInfo.requestType,
+                            error: isUnknownSchema ? "Unknown request schema" : "Invalid message",
+                            code: isUnknownSchema ? "unknown_schema" : "invalid_message",
+                        },
+                    }));
+                    return;
+                }
+                const errorMessage = `Invalid message: ${parsedMessage.error.message}`;
+                this.sendToClient(ws, wrapSessionMessage({
+                    type: "status",
+                    payload: {
+                        status: "error",
+                        message: errorMessage,
+                    },
+                }));
+                return;
+            }
+            const message = parsedMessage.data;
+            if (message.type === "ping") {
+                this.sendToClient(ws, { type: "pong" });
+                return;
+            }
+            if (pendingConnection) {
+                if (message.type === "hello") {
+                    this.handleHello({
+                        ws,
+                        message,
+                        pending: pendingConnection,
+                    });
+                    return;
+                }
+                pendingConnection.connectionLogger.warn({
+                    messageType: message.type,
+                }, "Rejected pending message before hello");
+                this.clearPendingConnection(ws);
+                try {
+                    ws.close(WS_CLOSE_INVALID_HELLO, "Session message before hello");
+                }
+                catch {
+                    // ignore close errors
+                }
+                return;
+            }
+            if (!activeConnection) {
+                this.logger.error("No connection found for websocket");
+                return;
+            }
+            if (message.type === "hello") {
+                activeConnection.connectionLogger.warn("Received hello on active connection");
+                try {
+                    ws.close(WS_CLOSE_INVALID_HELLO, "Unexpected hello");
+                }
+                catch {
+                    // ignore close errors
+                }
+                return;
+            }
+            if (message.type === "session") {
+                await activeConnection.session.handleMessage(message.message);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            let rawPayload = null;
+            let parsedPayload = null;
+            try {
+                const buffer = bufferFromWsData(data);
+                rawPayload = buffer.toString();
+                parsedPayload = JSON.parse(rawPayload);
+            }
+            catch (payloadError) {
+                rawPayload = rawPayload ?? "<unreadable>";
+                parsedPayload = parsedPayload ?? rawPayload;
+                const payloadErr = payloadError instanceof Error ? payloadError : new Error(String(payloadError));
+                this.logger.error({ err: payloadErr }, "Failed to decode raw payload");
+            }
+            const trimmedRawPayload = typeof rawPayload === "string" && rawPayload.length > 2000
+                ? `${rawPayload.slice(0, 2000)}... (truncated)`
+                : rawPayload;
+            log.error({
+                err,
+                rawPayload: trimmedRawPayload,
+                parsedPayload,
+            }, "Failed to parse/handle message");
+            if (this.pendingConnections.has(ws)) {
+                this.clearPendingConnection(ws);
+                try {
+                    ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
+                }
+                catch {
+                    // ignore close errors
+                }
+                return;
+            }
+            const requestInfo = extractRequestInfoFromUnknownWsInbound(parsedPayload);
+            if (requestInfo) {
+                this.sendToClient(ws, wrapSessionMessage({
+                    type: "rpc_error",
+                    payload: {
+                        requestId: requestInfo.requestId,
+                        requestType: requestInfo.requestType,
+                        error: "Invalid message",
+                        code: "invalid_message",
+                    },
+                }));
+                return;
+            }
+            this.sendToClient(ws, wrapSessionMessage({
+                type: "status",
+                payload: {
+                    status: "error",
+                    message: `Invalid message: ${err.message}`,
+                },
+            }));
+        }
+    }
+    getClientActivityState(session) {
+        const activity = session.getClientActivity();
+        if (!activity) {
+            return { deviceType: null, focusedAgentId: null, isStale: true, appVisible: false };
+        }
+        const now = Date.now();
+        const ageMs = now - activity.lastActivityAt.getTime();
+        const isStale = ageMs >= this.ACTIVITY_THRESHOLD_MS;
+        return {
+            deviceType: activity.deviceType,
+            focusedAgentId: activity.focusedAgentId,
+            isStale,
+            appVisible: activity.appVisible,
+        };
+    }
+    broadcastAgentAttention(params) {
+        const clientEntries = [];
+        for (const [ws, connection] of this.sessions) {
+            clientEntries.push({
+                ws,
+                state: this.getClientActivityState(connection.session),
+            });
+        }
+        const allStates = clientEntries.map((e) => e.state);
+        const agent = this.agentManager.getAgent(params.agentId);
+        if (agent?.labels?.ui !== "true") {
+            this.logger.debug({
+                agentId: params.agentId,
+                labels: agent?.labels ?? null,
+            }, "Skipping attention notification for non-UI agent");
+            return;
+        }
+        const notification = buildAgentAttentionNotificationPayload({
+            reason: params.reason,
+            serverId: this.serverId,
+            agentId: params.agentId,
+            assistantMessage: agent
+                ? findLatestAssistantMessageFromTimeline(agent.timeline)
+                : null,
+            permissionRequest: agent
+                ? findLatestPermissionRequest(agent.pendingPermissions)
+                : null,
+        });
+        for (const { ws, state } of clientEntries) {
+            const shouldNotify = computeShouldNotifyClient({
+                clientState: state,
+                allClientStates: allStates,
+                agentId: params.agentId,
+            });
+            const message = wrapSessionMessage({
+                type: "agent_stream",
+                payload: {
+                    agentId: params.agentId,
+                    event: {
+                        type: "attention_required",
+                        provider: params.provider,
+                        reason: params.reason,
+                        timestamp: new Date().toISOString(),
+                        shouldNotify,
+                        notification,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+            });
+            this.sendToClient(ws, message);
+        }
+    }
+}
+function extractSocketRequestMetadata(request) {
+    if (!request || typeof request !== "object") {
+        return {};
+    }
+    const record = request;
+    const host = typeof record.headers?.host === "string" ? record.headers.host : undefined;
+    const origin = typeof record.headers?.origin === "string" ? record.headers.origin : undefined;
+    const userAgent = typeof record.headers?.["user-agent"] === "string"
+        ? record.headers["user-agent"]
+        : undefined;
+    const remoteAddress = typeof record.socket?.remoteAddress === "string"
+        ? record.socket.remoteAddress
+        : undefined;
+    return {
+        ...(host ? { host } : {}),
+        ...(origin ? { origin } : {}),
+        ...(userAgent ? { userAgent } : {}),
+        ...(remoteAddress ? { remoteAddress } : {}),
+    };
+}
+function stringifyCloseReason(reason) {
+    if (typeof reason === "string") {
+        return reason.length > 0 ? reason : null;
+    }
+    if (Buffer.isBuffer(reason)) {
+        const text = reason.toString();
+        return text.length > 0 ? text : null;
+    }
+    if (reason == null) {
+        return null;
+    }
+    const text = String(reason);
+    return text.length > 0 ? text : null;
+}
+function extractRequestInfoFromUnknownWsInbound(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const record = payload;
+    // Session-wrapped messages
+    if (record.type === "session" && record.message && typeof record.message === "object") {
+        const msg = record.message;
+        if (typeof msg.requestId === "string") {
+            return {
+                requestId: msg.requestId,
+                ...(typeof msg.type === "string" ? { requestType: msg.type } : {}),
+            };
+        }
+    }
+    // Non-session messages (future-proof)
+    if (typeof record.requestId === "string") {
+        return {
+            requestId: record.requestId,
+            ...(typeof record.type === "string" ? { requestType: record.type } : {}),
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=websocket-server.js.map