@rynx-ai/server 0.1.11-beta.5 → 0.1.11-beta.51

package/dist/session-pending-inputs.js

@@ -0,0 +1,87 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_PENDING_INPUT_TTL_MS = 10 * 60_000;
+/**
+ * Process-live FIFO of web-composer inputs awaiting their native transcript
+ * echo. The message is deliberately not persisted when the send POST succeeds:
+ * the Provider transcript remains the sole durable writer. This index only
+ * keeps the temporary bubble recoverable across page rebinds until that echo
+ * arrives.
+ */
+export class SessionPendingInputIndex {
+    ttlMs;
+    now;
+    entries = new Map();
+    constructor(ttlMs = DEFAULT_PENDING_INPUT_TTL_MS, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    record(sessionId, input) {
+        this.evictStale(sessionId);
+        const pending = this.entries.get(sessionId) ?? new Map();
+        const pendingId = `pending_${randomUUID().replaceAll("-", "")}`;
+        pending.set(pendingId, {
+            pendingId,
+            clientMessageId: input.clientMessageId,
+            content: input.content.map((part) => ({ ...part })),
+            createdAt: this.now(),
+        });
+        this.entries.set(sessionId, pending);
+        return pendingId;
+    }
+    resolve(sessionId, pendingId) {
+        const pending = this.entries.get(sessionId);
+        if (!pending)
+            return;
+        pending.delete(pendingId);
+        if (pending.size === 0)
+            this.entries.delete(sessionId);
+    }
+    resolveOldest(sessionId) {
+        const input = this.peekOldest(sessionId);
+        if (input)
+            this.resolve(sessionId, input.pendingId);
+        return input;
+    }
+    peekOldest(sessionId) {
+        this.evictStale(sessionId);
+        const pending = this.entries.get(sessionId);
+        const pendingId = pending?.keys().next().value;
+        if (!pending || !pendingId)
+            return undefined;
+        const input = pending.get(pendingId);
+        return input ? cloneDrainedInput(input) : undefined;
+    }
+    findByClientMessageId(sessionId, clientMessageId) {
+        this.evictStale(sessionId);
+        const input = [...(this.entries.get(sessionId)?.values() ?? [])].find((entry) => entry.clientMessageId === clientMessageId);
+        return input ? clonePendingInput(input) : undefined;
+    }
+    snapshotFor(sessionId) {
+        this.evictStale(sessionId);
+        return [...(this.entries.get(sessionId)?.values() ?? [])].map(clonePendingInput);
+    }
+    deleteSession(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    evictStale(sessionId) {
+        const pending = this.entries.get(sessionId);
+        if (!pending)
+            return;
+        const cutoff = this.now() - this.ttlMs;
+        for (const [pendingId, input] of pending) {
+            if (input.createdAt < cutoff)
+                pending.delete(pendingId);
+        }
+        if (pending.size === 0)
+            this.entries.delete(sessionId);
+    }
+}
+function clonePendingInput(input) {
+    return {
+        pendingId: input.pendingId,
+        content: input.content.map((part) => ({ ...part })),
+    };
+}
+function cloneDrainedInput(input) {
+    return { ...clonePendingInput(input), clientMessageId: input.clientMessageId };
+}

package/dist/session-portal.d.ts

@@ -0,0 +1,54 @@
+import { type IncomingMessage, type Server as HttpServer } from "node:http";
+import type { Duplex } from "node:stream";
+import Koa from "koa";
+export declare const SESSION_PORTAL_HEADER = "x-rynx-session-portal";
+export declare const SESSION_PORTAL_QUERY = "portal";
+export declare const SESSION_PORTAL_SECRET_HEADER = "x-rynx-session-portal-secret";
+export declare const SESSION_PORTAL_SECRET_QUERY = "portal_secret";
+export declare const SESSION_PORTAL_EMBED_ORIGIN_QUERY = "embed_origin";
+export interface SessionPortalAuthorization {
+    portalId: string;
+    pluginId: string;
+    scope: "plugin_sessions" | "single_session";
+    access: "read_only" | "read_write";
+    embedOrigin?: string;
+    sessionId?: string;
+    expiresAt: string;
+}
+export interface SessionPortalAuthorizationPorts {
+    redeem(ticket: string, embedOrigin?: string): (SessionPortalAuthorization & {
+        secret: string;
+    }) | undefined;
+    authorize(portalId: string, secret: string): SessionPortalAuthorization | undefined;
+    inspect(portalId: string): SessionPortalAuthorization | undefined;
+    subscribeRevocations?(listener: (portalIds: readonly string[]) => void | Promise<void>): () => void;
+    ownsSession(pluginId: string, sessionId: string): boolean;
+}
+export interface SessionPortalOptions {
+    host: string;
+    port: number;
+    scheme: "http" | "https";
+    authorization: SessionPortalAuthorizationPorts;
+    controlOrigin: string;
+    controlWebDist: string;
+    shutdownSignal?: AbortSignal;
+}
+export interface SessionPortalServer {
+    server: HttpServer;
+    stopAccepting(): void;
+    shutdown(): Promise<void>;
+}
+declare class SessionPortalTransportRegistry {
+    private readonly transports;
+    track(portalId: string, close: () => void): () => void;
+    revoke(portalIds: readonly string[]): Promise<void>;
+}
+/** Session Portal is a narrow adapter in front of the one Control service. It
+ * serves the native SPA, validates Portal grants, and forwards only authorized
+ * Session HTTP calls to Control; it owns no Session or Runtime handlers. */
+export declare function createSessionPortalApp(options: SessionPortalOptions, transports?: SessionPortalTransportRegistry): Koa;
+export declare function startSessionPortal(options: SessionPortalOptions): Promise<SessionPortalServer>;
+export declare function authorizeSessionPortalWebSocket(request: IncomingMessage, ports: SessionPortalAuthorizationPorts, runtimeSelector: string, sessionId: string): SessionPortalAuthorization | undefined;
+export declare function rejectSessionPortalUpgrade(socket: Duplex): void;
+export declare function scheduleSessionPortalExpiry(expiresAt: string, onExpire: () => void): () => void;
+export {};