@someonegg/codex-hub 0.0.0-stage → 0.1.1

package/dist/server/server/http/session-updates-routes.js

@@ -0,0 +1,84 @@
+import { RepositoryQueryError } from "../repository/session-queries.js";
+import { SessionUpdatesError, } from "../updates/session-updates-service.js";
+import { invalid, only, optional } from "./query-params.js";
+import { sendJson } from "./router.js";
+import { SESSION_ID_PATTERN, SESSION_ROOT, sessionPath } from "./session-path.js";
+const UPDATES_PATH = new RegExp(`^${SESSION_ROOT}/${SESSION_ID_PATTERN}/updates$`);
+export function createSessionUpdatesRoutes(updates) {
+    return {
+        matches: (url) => UPDATES_PATH.test(url.pathname),
+        async handle(request, response, url) {
+            const headOnly = request.method === "HEAD";
+            if (request.method !== "GET" && !headOnly)
+                return false;
+            const { id } = sessionPath(url.pathname);
+            response.setHeader("Cache-Control", "no-store");
+            const abort = new AbortController();
+            const onDisconnect = () => {
+                if (!response.writableEnded)
+                    abort.abort();
+            };
+            request.once("aborted", onDisconnect);
+            response.once("close", onDisconnect);
+            try {
+                const result = await updates.wait(id, parseUpdatesQuery(url.searchParams), abort.signal);
+                if (abort.signal.aborted || response.destroyed)
+                    return true;
+                if (result === null)
+                    return noContent(response);
+                sendJson(response, 200, result, headOnly);
+                return true;
+            }
+            finally {
+                request.removeListener("aborted", onDisconnect);
+                response.removeListener("close", onDisconnect);
+            }
+        },
+        mapError(error, request, response) {
+            const headOnly = request.method === "HEAD";
+            if (error instanceof RepositoryQueryError) {
+                const status = error.code === "timeline_changed" ? 409 : 400;
+                sendJson(response, status, {
+                    error: { code: error.code, message: error.message },
+                }, headOnly);
+                return true;
+            }
+            if (error instanceof SessionUpdatesError) {
+                const status = error.code === "session_not_found" ? 404 : 429;
+                if (status === 429)
+                    response.setHeader("Retry-After", "2");
+                sendJson(response, status, {
+                    error: { code: error.code, message: error.message },
+                }, headOnly);
+                return true;
+            }
+            if (error instanceof DOMException && error.name === "AbortError") {
+                if (request.destroyed || response.destroyed)
+                    return true;
+                return noContent(response);
+            }
+            return false;
+        },
+    };
+}
+function parseUpdatesQuery(params) {
+    only(params, ["cursor", "after"]);
+    const cursor = optional(params, "cursor");
+    const after = optional(params, "after");
+    if (cursor === undefined)
+        invalid("cursor is required for automatic updates");
+    if (after === undefined)
+        invalid("after is required for automatic updates");
+    if (!/^[A-Za-z0-9_-]{43}$/.test(after))
+        invalid("after is malformed");
+    return {
+        cursor: cursor,
+        after: after,
+    };
+}
+function noContent(response) {
+    response.statusCode = 204;
+    response.end();
+    return true;
+}
+//# sourceMappingURL=session-updates-routes.js.map

package/dist/server/server/http/terminal-preview-websocket.js

@@ -0,0 +1,179 @@
+import WebSocket, { WebSocketServer } from "ws";
+import { SessionInteractionError, } from "../interaction/interaction-service.js";
+import { InteractionTransportError } from "../interaction/transport.js";
+import { SESSION_ID_PATTERN, SESSION_ROOT } from "./session-path.js";
+const PATH = new RegExp(`^${SESSION_ROOT}/(${SESSION_ID_PATTERN})/terminal-preview$`);
+const MAX_BUFFERED_BYTES = 2 * 1024 * 1024;
+export function createTerminalPreviewWebSocket(interaction) {
+    const server = new WebSocketServer({
+        noServer: true,
+        perMessageDeflate: false,
+        maxPayload: 1024,
+    });
+    const connections = new Map();
+    const counts = new Map();
+    let closing = false;
+    let shutdownTimer;
+    const heartbeat = setInterval(() => {
+        for (const [socket, connection] of connections) {
+            if (!connection.alive)
+                socket.terminate();
+            else if (socket.readyState === WebSocket.OPEN) {
+                connection.alive = false;
+                socket.ping();
+            }
+        }
+    }, 30_000);
+    heartbeat.unref();
+    return {
+        handle(request, socket, head) {
+            socket.on("error", () => socket.destroy());
+            if (closing)
+                return reject(socket, 503, "Service Unavailable");
+            let url;
+            try {
+                url = new URL(request.url ?? "/", "http://localhost");
+            }
+            catch {
+                return reject(socket, 400, "Bad Request");
+            }
+            const match = PATH.exec(url.pathname);
+            if (!match)
+                return reject(socket, 404, "Not Found");
+            if (url.search)
+                return reject(socket, 400, "Bad Request");
+            const secure = "encrypted" in request.socket && request.socket.encrypted;
+            if (request.headers.origin &&
+                request.headers.origin !== `${secure ? "https" : "http"}://${request.headers.host}`)
+                return reject(socket, 403, "Forbidden");
+            server.handleUpgrade(request, socket, head, (ws) => {
+                const sessionId = match[1];
+                const abort = new AbortController();
+                const count = counts.get(sessionId) ?? 0;
+                const capacityExceeded = connections.size >= 100 || count >= 10;
+                let release;
+                const stop = () => {
+                    abort.abort();
+                    release?.();
+                    release = undefined;
+                };
+                const connection = { alive: true, stop };
+                connections.set(ws, connection);
+                counts.set(sessionId, count + 1);
+                const send = (value) => {
+                    if (abort.signal.aborted || ws.readyState !== WebSocket.OPEN)
+                        return;
+                    if (ws.bufferedAmount > MAX_BUFFERED_BYTES) {
+                        stop();
+                        ws.close(1013, "Preview consumer is too slow");
+                        return;
+                    }
+                    ws.send(JSON.stringify(value), (error) => {
+                        if (error) {
+                            stop();
+                            ws.terminate();
+                        }
+                    });
+                };
+                const finish = (message) => {
+                    if (abort.signal.aborted)
+                        return;
+                    send(message);
+                    stop();
+                    ws.close(message.retryable ? 1013 : 1008, message.code);
+                };
+                const fail = (error) => finish(previewError(error));
+                ws.on("error", () => {
+                    stop();
+                    ws.terminate();
+                });
+                ws.on("pong", () => {
+                    connection.alive = true;
+                });
+                ws.on("message", () => {
+                    stop();
+                    ws.close(1008, "Preview accepts no application messages");
+                });
+                ws.once("close", () => {
+                    stop();
+                    connections.delete(ws);
+                    const remaining = (counts.get(sessionId) ?? 1) - 1;
+                    if (remaining)
+                        counts.set(sessionId, remaining);
+                    else
+                        counts.delete(sessionId);
+                    if (closing && !connections.size)
+                        clearTimeout(shutdownTimer);
+                });
+                if (capacityExceeded) {
+                    finish({
+                        type: "error",
+                        code: "preview_capacity_exceeded",
+                        message: "Too many terminal preview connections",
+                        retryable: true,
+                    });
+                }
+                else if (!interaction) {
+                    fail(new SessionInteractionError("interaction_not_supported", "Interaction is not enabled"));
+                }
+                else {
+                    void interaction
+                        .subscribePreview(sessionId, send, fail, abort.signal)
+                        .then((close) => {
+                        if (abort.signal.aborted)
+                            close();
+                        else
+                            release = close;
+                    })
+                        .catch(fail);
+                }
+            });
+        },
+        close() {
+            if (closing)
+                return;
+            closing = true;
+            clearInterval(heartbeat);
+            for (const [socket, connection] of connections) {
+                connection.stop();
+                socket.close(1001, "Server shutting down");
+            }
+            if (connections.size) {
+                shutdownTimer = setTimeout(() => {
+                    for (const socket of connections.keys())
+                        socket.terminate();
+                }, 1000);
+                shutdownTimer.unref();
+            }
+            server.close();
+        },
+    };
+}
+function reject(socket, status, reason) {
+    socket.end(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+}
+function previewError(error) {
+    if (error instanceof SessionInteractionError) {
+        return {
+            type: "error",
+            code: error.code,
+            message: error.message,
+            retryable: ["interaction_failed", "operation_result_unknown", "session_busy"].includes(error.code),
+        };
+    }
+    if (error instanceof InteractionTransportError) {
+        return {
+            type: "error",
+            code: error.code === "disconnected" ? "interaction_not_connected" : "interaction_failed",
+            message: error.message,
+            retryable: error.code !== "disconnected",
+        };
+    }
+    return {
+        type: "error",
+        code: "interaction_failed",
+        message: "Terminal preview is temporarily unavailable",
+        retryable: true,
+    };
+}
+//# sourceMappingURL=terminal-preview-websocket.js.map

package/dist/server/server/http/upload-routes.js

@@ -0,0 +1,74 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, mkdtemp, open, realpath, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { MAX_UPLOAD_BYTES } from "../../shared/uploads.js";
+import { RequestBodyError } from "./request-body.js";
+import { sendJson } from "./router.js";
+let defaultDirectory;
+export async function uploadDirectory(configured) {
+    if (configured !== undefined) {
+        await mkdir(configured, { recursive: true });
+        return realpath(configured);
+    }
+    defaultDirectory ??= mkdtemp(join(tmpdir(), "codex-hub-uploads-")).then((directory) => realpath(directory));
+    return defaultDirectory;
+}
+export function createUploadRoutes(directory) {
+    return {
+        matches: (url) => url.pathname === "/api/v1/uploads",
+        async handle(request, response, url) {
+            if (request.method !== "POST") {
+                response.setHeader("Allow", "POST");
+                sendJson(response, 405, {
+                    error: { code: "method_not_allowed", message: "Use POST to upload files" },
+                });
+                return true;
+            }
+            const protocol = "encrypted" in request.socket && request.socket.encrypted ? "https" : "http";
+            if (request.headers.origin &&
+                request.headers.origin !== `${protocol}://${request.headers.host}`) {
+                sendJson(response, 403, {
+                    error: { code: "forbidden", message: "Cross-origin uploads are not allowed" },
+                });
+                return true;
+            }
+            const tooLarge = () => new RequestBodyError(413, "body_too_large", "Files must be at most 20 MiB");
+            if (Number(request.headers["content-length"]) > MAX_UPLOAD_BYTES) {
+                request.resume();
+                throw tooLarge();
+            }
+            const extension = extname(url.searchParams.get("filename") ?? "");
+            const safeExtension = /^\.[a-zA-Z0-9]{1,16}$/.test(extension) ? extension : "";
+            const path = join(await uploadDirectory(directory), `${randomUUID()}${safeExtension}`);
+            const file = await open(path, "wx", 0o600);
+            let complete = false;
+            try {
+                let bytes = 0;
+                for await (const chunk of request.iterator({ destroyOnReturn: false })) {
+                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    bytes += buffer.length;
+                    if (bytes > MAX_UPLOAD_BYTES) {
+                        request.resume();
+                        throw tooLarge();
+                    }
+                    await file.writeFile(buffer);
+                }
+                if (!request.complete || request.aborted)
+                    throw new Error("Upload interrupted");
+                await file.close();
+                complete = true;
+                sendJson(response, 201, { path });
+            }
+            finally {
+                if (!complete) {
+                    await file.close().catch(() => undefined);
+                    await unlink(path);
+                }
+            }
+            return true;
+        },
+        mapError: () => false,
+    };
+}
+//# sourceMappingURL=upload-routes.js.map

package/dist/server/server/interaction/interaction-service.js

@@ -0,0 +1,247 @@
+import { normalizeMessage } from "./message.js";
+import { paneBindings } from "./pane-binding-manager.js";
+import { TerminalPreviewService } from "./terminal-preview-service.js";
+import { attachCommand } from "./tmux-launcher.js";
+import { InteractionTransportError, } from "./transport.js";
+export class SessionInteractionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SessionInteractionError";
+    }
+}
+export class SessionInteractionService {
+    sessions;
+    enabled;
+    tmux;
+    bindings;
+    runtime;
+    #busy = new Set();
+    #previews;
+    #unsubscribe;
+    close() {
+        this.#unsubscribe();
+        this.#previews.close();
+    }
+    constructor(sessions, enabled, tmux, bindings = paneBindings, listener) {
+        this.sessions = sessions;
+        this.enabled = enabled;
+        this.tmux = tmux;
+        this.bindings = bindings;
+        this.#previews = new TerminalPreviewService((binding, assertOwner) => this.#perform(() => this.tmux.captureTerminal(binding, assertOwner)), listener, (binding) => this.tmux.resolveTarget({ valid: true, ordinal: 0, ...binding }));
+        this.#unsubscribe = bindings.subscribe(() => this.#previews.invalidate());
+    }
+    setBusy(sessionId, busy) {
+        if (busy)
+            this.#busy.add(sessionId);
+        else
+            this.#busy.delete(sessionId);
+    }
+    async resolveTarget(sessionId) {
+        const session = await this.sessions.getInteractionSession(sessionId);
+        if (!session)
+            throw new Error("Session not found");
+        const attempt = this.bindings.latest(sessionId);
+        if (this.bindings.replacement(sessionId) !== null)
+            return null;
+        if (!attempt?.valid)
+            return null;
+        const target = await this.tmux.resolveTarget(attempt);
+        return target && this.bindings.owns(sessionId, target) ? target : null;
+    }
+    sendExitKeys(target, sessionId, keys, assertActive) {
+        return this.tmux.sendKeys(target, keys, () => {
+            assertActive();
+            this.#assertOwner(sessionId, target);
+        });
+    }
+    killTarget(target, sessionId, assertActive) {
+        return this.tmux.killPane(target, () => {
+            assertActive();
+            this.#assertOwner(sessionId, target);
+        });
+    }
+    async inspectTarget(target, sessionId) {
+        this.#assertOwner(sessionId, target);
+        const state = await this.tmux.inspect(target);
+        this.#assertOwner(sessionId, target);
+        return state;
+    }
+    #assertAvailable(sessionId) {
+        if (this.#busy.has(sessionId))
+            throw new SessionInteractionError("session_busy", "Session management is in progress; input is temporarily unavailable");
+    }
+    async describe(sessionId) {
+        const session = await this.sessions.getInteractionSession(sessionId);
+        if (session === null)
+            return null;
+        return this.describeSnapshot(sessionId, session);
+    }
+    async describeSnapshot(sessionId, session) {
+        if (!this.#supported(session))
+            return { supported: false, attachCommand: null };
+        const attempt = this.bindings.latest(sessionId);
+        if (attempt === null)
+            return response("unbound");
+        if (!attempt.valid) {
+            return response("disconnected");
+        }
+        const replacement = this.bindings.replacement(sessionId);
+        if (replacement !== null) {
+            const unchanged = () => this.bindings.latest(sessionId) === attempt &&
+                this.bindings.replacement(sessionId) === replacement;
+            try {
+                const checked = await this.#check(attempt);
+                if (!unchanged())
+                    return this.#currentState(sessionId);
+                if (checked === null)
+                    return response("disconnected");
+                const target = await this.sessions.getInteractionSession(replacement);
+                if (!unchanged())
+                    return this.#currentState(sessionId);
+                return { ...response("superseded"), supersededBySessionId: target ? replacement : null };
+            }
+            catch {
+                return unchanged() ? response("unknown") : this.#currentState(sessionId);
+            }
+        }
+        try {
+            const checked = await this.#check(attempt);
+            if (this.bindings.latest(sessionId) !== attempt || !this.bindings.owns(sessionId, attempt))
+                return this.#currentState(sessionId);
+            return response(checked === null ? "disconnected" : "connected", checked?.binding);
+        }
+        catch {
+            if (this.bindings.latest(sessionId) !== attempt || !this.bindings.owns(sessionId, attempt))
+                return this.#currentState(sessionId);
+            return response("unknown");
+        }
+    }
+    #currentState(sessionId) {
+        const attempt = this.bindings.latest(sessionId);
+        if (attempt === null)
+            return response("unbound");
+        if (!attempt.valid)
+            return response("disconnected");
+        return response("unknown");
+    }
+    #check(attempt) {
+        const connection = this.runtime ? this.runtime.probe(attempt) : this.tmux.connect(attempt);
+        return connection.then((binding) => (binding === null ? null : { attempt, binding }), (error) => {
+            if (error instanceof InteractionTransportError && error.code === "disconnected")
+                return null;
+            throw error;
+        });
+    }
+    async matchesTarget(sessionId, target) {
+        const resolved = await this.#resolve(sessionId);
+        return (resolved.binding.socketPath === target.socketPath && resolved.binding.paneId === target.paneId);
+    }
+    async sendMessage(sessionId, message) {
+        message = normalizeMessage(message);
+        this.#assertAvailable(sessionId);
+        const { binding } = await this.#resolve(sessionId);
+        this.#assertAvailable(sessionId);
+        await this.#perform(() => this.tmux.sendMessage(binding, message, () => this.#assertInputAllowed(sessionId, binding)));
+    }
+    async handoffPaneBinding(sessionId) {
+        this.#assertAvailable(sessionId);
+        const { binding, bindingCommand } = await this.#resolve(sessionId);
+        this.#assertAvailable(sessionId);
+        await this.#perform(() => this.tmux.sendMessage(binding, bindingCommand, () => this.#assertInputAllowed(sessionId, binding)));
+    }
+    async sendKeys(sessionId, keys) {
+        this.#assertAvailable(sessionId);
+        const { binding, keyBindings } = await this.#resolve(sessionId);
+        this.#assertAvailable(sessionId);
+        const mapped = keys.map((key) => keyBindings[key]);
+        await this.#perform(() => this.tmux.sendKeys(binding, mapped, () => this.#assertInputAllowed(sessionId, binding)));
+    }
+    async subscribePreview(sessionId, frame, fail, signal) {
+        const { binding } = await this.#resolve(sessionId);
+        if (signal.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        return this.#previews.subscribe(sessionId, binding, () => this.#assertOwner(sessionId, binding), frame, fail, signal);
+    }
+    async #resolve(sessionId) {
+        const session = await this.sessions.getInteractionSession(sessionId);
+        if (session === null) {
+            throw new SessionInteractionError("session_not_found", "Session not found");
+        }
+        if (!this.#supported(session)) {
+            throw new SessionInteractionError("interaction_not_supported", "Interaction is not supported for this session");
+        }
+        const interaction = session.interaction;
+        const attempt = this.bindings.latest(sessionId);
+        if (attempt === null || !attempt.valid) {
+            throw new SessionInteractionError("interaction_not_connected", "The session is not connected to a tmux pane");
+        }
+        this.#assertOwner(sessionId, attempt);
+        let checked;
+        try {
+            checked = await this.#check(attempt);
+        }
+        catch (error) {
+            return this.#translateConnectionError(error);
+        }
+        if (checked === null)
+            return this.#translateConnectionError(null);
+        this.#assertOwner(sessionId, attempt);
+        return {
+            ...checked,
+            keyBindings: interaction.keyBindings,
+            bindingCommand: interaction.bindingCommand,
+        };
+    }
+    #assertInputAllowed(sessionId, binding) {
+        this.#assertAvailable(sessionId);
+        this.#assertOwner(sessionId, binding);
+    }
+    #assertOwner(sessionId, target) {
+        if (!this.bindings.owns(sessionId, target)) {
+            throw new SessionInteractionError("interaction_not_connected", "The pane binding has been superseded");
+        }
+    }
+    async #perform(operation) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (error instanceof InteractionTransportError) {
+                if (error.code === "disconnected") {
+                    throw new SessionInteractionError("interaction_not_connected", "The tmux target is no longer connected");
+                }
+                if (error.code === "timeout") {
+                    throw new SessionInteractionError("operation_result_unknown", "The tmux operation timed out; its result is unknown and was not retried");
+                }
+                if (error.code === "command_failed") {
+                    throw new SessionInteractionError("interaction_failed", "tmux could not complete the interaction operation");
+                }
+            }
+            throw error;
+        }
+    }
+    #translateConnectionError(error) {
+        if (error instanceof InteractionTransportError && error.code === "timeout") {
+            throw new SessionInteractionError("operation_result_unknown", "The tmux validation timed out; its result is unknown and was not retried");
+        }
+        throw new SessionInteractionError(error === null ? "interaction_not_connected" : "interaction_failed", error === null
+            ? "The session is not connected to a valid tmux pane"
+            : "tmux target validation failed");
+    }
+    #supported(session) {
+        return this.enabled && !session.archived && session.interaction !== null;
+    }
+}
+function response(state, binding) {
+    return {
+        supported: true,
+        state,
+        supersededBySessionId: null,
+        attachCommand: binding?.sessionName
+            ? attachCommand(binding.socketPath, binding.sessionName)
+            : null,
+    };
+}
+//# sourceMappingURL=interaction-service.js.map

package/dist/server/server/interaction/message.js

@@ -0,0 +1,19 @@
+import { MAX_INTERACTION_MESSAGE_BYTES } from "../../shared/interaction.js";
+export class MessageValidationError extends Error {
+    code = "invalid_message";
+    constructor(message) {
+        super(message);
+    }
+}
+export function normalizeMessage(message) {
+    const normalized = message.replace(/\r\n?/g, "\n");
+    const bytes = Buffer.byteLength(normalized, "utf8");
+    if (normalized.trim().length === 0) {
+        throw new MessageValidationError("message must not be blank");
+    }
+    if (bytes > MAX_INTERACTION_MESSAGE_BYTES) {
+        throw new MessageValidationError(`message must not exceed ${MAX_INTERACTION_MESSAGE_BYTES} UTF-8 bytes`);
+    }
+    return normalized;
+}
+//# sourceMappingURL=message.js.map

package/dist/server/server/interaction/pane-binding-manager.js

@@ -0,0 +1,60 @@
+/** Retains only the latest session event and latest claim on each pane. */
+export class PaneBindingManager {
+    #sessions = new Map();
+    #panes = new Map();
+    #listeners = new Set();
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    submit(event) {
+        const latest = this.#sessions.get(event.sessionId);
+        let changed = false;
+        if (!latest || compare(event, latest) > 0) {
+            this.#sessions.set(event.sessionId, event);
+            changed = true;
+        }
+        if (!event.attempt.valid) {
+            if (changed)
+                for (const listener of this.#listeners)
+                    listener();
+            return;
+        }
+        const key = paneKey(event.attempt);
+        const owner = this.#panes.get(key);
+        if (!owner || compare(event, owner) > 0) {
+            this.#panes.set(key, event);
+            changed = true;
+        }
+        if (changed)
+            for (const listener of this.#listeners)
+                listener();
+    }
+    latest(sessionId) {
+        return this.#sessions.get(sessionId)?.attempt ?? null;
+    }
+    replacement(sessionId) {
+        const event = this.#sessions.get(sessionId);
+        if (!event?.attempt.valid)
+            return null;
+        const owner = this.#panes.get(paneKey(event.attempt));
+        return owner && compare(owner, event) !== 0 ? owner.sessionId : null;
+    }
+    owns(sessionId, pane) {
+        const attempt = this.latest(sessionId);
+        return (!!attempt?.valid && paneKey(attempt) === paneKey(pane) && this.replacement(sessionId) === null);
+    }
+}
+function paneKey(pane) {
+    return JSON.stringify([pane.socketPath, pane.paneId]);
+}
+function compare(left, right) {
+    return (left.time - right.time ||
+        (left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1 : 0) ||
+        left.ordinal - right.ordinal ||
+        left.position - right.position);
+}
+export const paneBindings = new PaneBindingManager();
+//# sourceMappingURL=pane-binding-manager.js.map

package/dist/server/server/interaction/reconcile-session-state.js

@@ -0,0 +1,21 @@
+/** Reconcile the read result with the later interaction observation. */
+export function reconcileSessionState(value) {
+    if (value.session.status !== "archived" && value.interaction.supported) {
+        const connected = value.interaction.state === "connected";
+        value = {
+            ...value,
+            session: {
+                ...value.session,
+                status: connected ? "live" : "normal",
+                resume: connected || value.interaction.state === "unknown"
+                    ? {
+                        allowed: false,
+                        reason: connected ? "Session is already live" : "Connection validation is unknown",
+                    }
+                    : value.session.resume,
+            },
+        };
+    }
+    return value;
+}
+//# sourceMappingURL=reconcile-session-state.js.map