@rynx-ai/server 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/server.js

@@ -10,6 +10,8 @@ import { attachBrowserSurfaceWs } from "./browser-surface-ws.js";
 import { attachEmulatorSurfaceWs } from "./emulator-surface-ws.js";
 import { attachDesktopBrowserHostServer, } from "./desktop-browser-host.js";
 import { resolveControlWebDist, sendSpaFile } from "./control-web-dist.js";
+import { startSessionPortal, } from "./session-portal.js";
+export { createSessionPortalApp, startSessionPortal } from "./session-portal.js";
 import { SessionRuntimeIndex } from "./session-runtime-index.js";
 import { createRunnerSessionTerminalHost, } from "./session-terminal-host.js";
 import { runtimeWebAccessPolicyForBindHost, } from "./runtime-web-auth.js";
@@ -59,6 +61,8 @@ export function createSessionRuntimeServices(input) {
         ...(input.sessionContextProvider
             ? { sessionContextProvider: input.sessionContextProvider }
             : {}),
+        ...(input.admissionOpen ? { admissionOpen: input.admissionOpen } : {}),
+        ...(input.admissionReserve ? { admissionReserve: input.admissionReserve } : {}),
     });
     const sessionBus = new InMemorySessionBus();
     const sessionRuntimeIndex = new SessionRuntimeIndex();
@@ -135,7 +139,7 @@ export function createApp({ config = loadConfig(), control } = {}) {
     }
     return app;
 }
-export async function startServer({ config = loadConfig(), control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, } = {}) {
+export async function startServer({ config = loadConfig(), control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, sessionPortalAuthorization, } = {}) {
     const runtimeWebAccess = runtimeWebAccessPolicyForBindHost(config.HOST);
     const desktopBrowserManagementToken = desktopBrowserHost
         ? requireDaemonManagementToken(daemonManagement)
@@ -158,6 +162,46 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 return { cwd: session.workspace.cwd };
             },
         });
+    const controlShutdown = new AbortController();
+    const controlSurface = control
+        ? {
+            deps: control,
+            runtime: conversationRuntime,
+            sessionBus,
+            sessionLog,
+            runnerManager,
+            sessionStore,
+            pluginRuntimeStatus: pluginRuntime
+                ? () => pluginRuntime.statusSnapshot()
+                : undefined,
+            daemonManagement,
+            remoteRuntime,
+            remoteRuntimeAdmin,
+            runtimeTargetControl,
+            runtimeConnectionResolver,
+            localSessionResources,
+            localMachineSessions,
+            sessionEmulators,
+            shutdownSignal: controlShutdown.signal,
+            sessionRuntimeIndex,
+            sessionLifecycle,
+            runtimeLocalBrowser,
+            providerClis,
+        }
+        : undefined;
+    const sessionPortalConfig = config.RYNX_SESSION_PORTAL_PORT !== undefined
+        ? (() => {
+            if (runtimeWebAccess.mode !== "loopback") {
+                throw new Error("Session Portal requires the ordinary Control listener to bind loopback only");
+            }
+            const controlWebDist = resolveControlWebDist();
+            if (!sessionPortalAuthorization || !controlSurface || !controlWebDist) {
+                throw new Error("Session Portal requires authorization, Control services, and the native Control Web build");
+            }
+            return { authorization: sessionPortalAuthorization, controlWebDist };
+        })()
+        : undefined;
+    let sessionPortalServer;
     if (pluginRuntime) {
         if (!sessionRegistry)
             throw new Error("plugin runtime requires a machine session registry");
@@ -179,7 +223,17 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 }),
             },
             interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
+            terminateSession: (sessionId) => runnerManager.terminateLiveSession(sessionId),
             resolveSessionInteraction: (sessionId, interactionId, resolution) => runnerManager.resolveInteraction(sessionId, interactionId, resolution),
+            ...(sessionPortalConfig
+                ? {
+                    sessionPortal: {
+                        scheme: "http",
+                        bindHost: config.RYNX_SESSION_PORTAL_HOST,
+                        port: config.RYNX_SESSION_PORTAL_PORT,
+                    },
+                }
+                : {}),
         });
     }
     // Provider TUI `/clear`·`/fork` uses the same publication boundary as an
@@ -195,55 +249,40 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             kind: r.kind,
         });
     });
-    const controlShutdown = new AbortController();
     const app = createApp({
         config,
-        control: control
-            ? {
-                deps: control,
-                runtime: conversationRuntime,
-                sessionBus,
-                sessionLog,
-                runnerManager,
-                sessionStore,
-                pluginRuntimeStatus: pluginRuntime
-                    ? () => pluginRuntime.statusSnapshot()
-                    : undefined,
-                daemonManagement,
-                remoteRuntime,
-                remoteRuntimeAdmin,
-                runtimeTargetControl,
-                runtimeConnectionResolver,
-                localSessionResources,
-                localMachineSessions,
-                sessionEmulators,
-                shutdownSignal: controlShutdown.signal,
-                sessionRuntimeIndex,
-                sessionLifecycle,
-                runtimeLocalBrowser,
-                providerClis,
-            }
-            : undefined,
+        control: controlSurface,
     });
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+        let startupWebSocketServers = [];
+        const rejectBeforeListening = (error) => reject(error);
         const server = app.listen(config.PORT, config.HOST, () => {
+            server.off("error", rejectBeforeListening);
+            void finishStartup(server).catch(async (error) => {
+                controlShutdown.abort(asError(error));
+                sessionPortalServer?.stopAccepting();
+                server.closeAllConnections?.();
+                await Promise.allSettled([
+                    closeWebSocketServers(startupWebSocketServers),
+                    sessionPortalServer?.shutdown() ?? Promise.resolve(),
+                    new Promise((done) => server.close(() => done())),
+                    Promise.resolve(daemonManagement?.pluginManagement?.dispose?.()),
+                    Promise.resolve(pluginRuntime?.dispose()),
+                    runnerManager.stop(),
+                ]);
+                reject(error);
+            });
+        });
+        server.once("error", rejectBeforeListening);
+        const finishStartup = async (server) => {
             console.log(JSON.stringify({
                 level: config.LOG_LEVEL,
                 msg: "Harness agent server listening",
                 host: config.HOST,
                 port: config.PORT,
-                runtime: config.AGENT_RUNTIME,
-                model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
+                runtime: config.DEFAULT_RUNTIME,
+                model: resolveRuntimeModel(config, config.DEFAULT_RUNTIME),
             }));
-            const startup = pluginRuntime?.startPluginRuntimes() ?? Promise.resolve();
-            void startup.catch((error) => {
-                console.error(JSON.stringify({
-                    level: "error",
-                    type: "plugin-runtime",
-                    event: "startup_failed",
-                    error: error instanceof Error ? error.message : String(error),
-                }));
-            });
             const webSocketServers = [
                 attachTerminalWs(server, {
                     runtimeConnectionResolver,
@@ -262,9 +301,36 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             if (control?.emulator) {
                 webSocketServers.push(attachEmulatorTouchWs(server, { emulator: control.emulator }));
             }
+            startupWebSocketServers = webSocketServers;
+            if (sessionPortalConfig) {
+                sessionPortalServer = await startSessionPortal({
+                    host: config.RYNX_SESSION_PORTAL_HOST,
+                    port: config.RYNX_SESSION_PORTAL_PORT,
+                    scheme: "http",
+                    authorization: sessionPortalConfig.authorization,
+                    controlOrigin: listeningHttpOrigin(server),
+                    controlWebDist: sessionPortalConfig.controlWebDist,
+                    shutdownSignal: controlShutdown.signal,
+                });
+            }
+            const startup = pluginRuntime?.startPluginRuntimes() ?? Promise.resolve();
+            void startup.catch((error) => {
+                console.error(JSON.stringify({
+                    level: "error",
+                    type: "plugin-runtime",
+                    event: "startup_failed",
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+            });
             resolve(bindServerLifecycle(server, {
-                fence: () => controlShutdown.abort(new Error("Rynx server is shutting down")),
-                closeUpgrades: () => closeWebSocketServers(webSocketServers),
+                fence: () => {
+                    controlShutdown.abort(new Error("Rynx server is shutting down"));
+                    sessionPortalServer?.stopAccepting();
+                },
+                closeUpgrades: () => Promise.all([
+                    closeWebSocketServers(webSocketServers),
+                    sessionPortalServer?.shutdown() ?? Promise.resolve(),
+                ]).then(() => undefined),
                 cleanup: async () => runCleanupSteps([
                     () => startup.catch(() => undefined),
                     () => Promise.resolve(daemonManagement?.pluginManagement?.dispose?.()),
@@ -272,9 +338,17 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                     () => runnerManager.stop(),
                 ]),
             }));
-        });
+        };
     });
 }
+function listeningHttpOrigin(server) {
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Control listener did not expose an HTTP address");
+    }
+    const host = address.address.includes(":") ? `[${address.address}]` : address.address;
+    return `http://${host}:${address.port}`;
+}
 function requireDaemonManagementToken(host) {
     const token = host?.managementToken;
     const bytes = typeof token === "string" ? Buffer.byteLength(token, "utf8") : 0;

package/dist/session-browser-service.d.ts

@@ -1,3 +1,4 @@
+import type { AdmissionReservation } from "@rynx-ai/core";
 import { type RuntimeBrowserCloseParams, type RuntimeBrowserCloseResult, type RuntimeBrowserExecutionBackend, type RuntimeBrowserOpenParams, type RuntimeBrowserPageCreateParams, type RuntimeBrowserPageMutationParams, type RuntimeBrowserPageNavigateParams, type RuntimeBrowserState, type RuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
 import type { RuntimeBrowserSurfaceFormat, RuntimeBrowserSurfaceInputEvent } from "@rynx-ai/protocol/runtime-browser-surface";
 import { type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -155,6 +156,11 @@ export interface SessionBrowserServiceOptions {
     pageIdFactory?: () => string;
     /** Injectable boot nonce; production randomization fences stale pre-restart mutations. */
     bootGenerationSeed?: number;
+    /**
+     * Synchronous daemon admission fence. A successful reservation is held until
+     * Browser open has either failed or registered the physical Host handle.
+     */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export type SessionBrowserHostErrorCode = "unavailable" | "page_not_found" | "capacity" | "outcome_unknown";
 /** Expected failure reported by a Browser Host implementation. */
@@ -181,6 +187,7 @@ export declare class SessionBrowserService {
     private readonly observers;
     private readonly pageIdFactory;
     private readonly bootGenerationSeed;
+    private readonly admissionReserve?;
     private shuttingDown;
     private closeAllPromise?;
     constructor(ports: SessionBrowserServicePorts, options?: SessionBrowserServiceOptions);
@@ -225,6 +232,7 @@ export declare class SessionBrowserService {
     closeAll(): Promise<void>;
     private closeEveryRecord;
     private createBrowser;
+    private reserveOpenAdmission;
     private closeUnavailableForRecreate;
     private pageMutation;
     private pageMutationParsed;

package/dist/session-browser-service.js

@@ -42,12 +42,14 @@ export class SessionBrowserService {
     observers = new Set();
     pageIdFactory;
     bootGenerationSeed;
+    admissionReserve;
     shuttingDown = false;
     closeAllPromise;
     constructor(ports, options = {}) {
         this.ports = ports;
         this.pageIdFactory = options.pageIdFactory ?? (() => `page_${randomUUID()}`);
         this.bootGenerationSeed = options.bootGenerationSeed ?? randomBootGenerationSeed();
+        this.admissionReserve = options.admissionReserve;
         if (!Number.isSafeInteger(this.bootGenerationSeed) ||
             this.bootGenerationSeed < 0 ||
             this.bootGenerationSeed >= Number.MAX_SAFE_INTEGER) {
@@ -224,29 +226,35 @@ export class SessionBrowserService {
         });
     }
     async open(input) {
-        const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
-        return this.exclusive(params.sessionId, async () => {
-            this.ensureRunning();
-            await this.ensureSessionExists(params.sessionId);
-            const existing = this.records.get(params.sessionId);
-            if (existing?.status === "opening") {
-                return this.project(existing);
-            }
-            if (existing?.status === "ready") {
-                try {
-                    await this.reconcileForRead(existing);
+        const admission = this.reserveOpenAdmission();
+        try {
+            const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
+            return await this.exclusive(params.sessionId, async () => {
+                this.ensureRunning();
+                await this.ensureSessionExists(params.sessionId);
+                const existing = this.records.get(params.sessionId);
+                if (existing?.status === "opening") {
                     return this.project(existing);
                 }
-                catch {
-                    // An App Host may have gone away immediately before this open. The
-                    // failed reconciliation marks the old generation unavailable, so an
-                    // idempotent open can recreate it on the current preferred Host.
+                if (existing?.status === "ready") {
+                    try {
+                        await this.reconcileForRead(existing);
+                        return this.project(existing);
+                    }
+                    catch {
+                        // An App Host may have gone away immediately before this open. The
+                        // failed reconciliation marks the old generation unavailable, so an
+                        // idempotent open can recreate it on the current preferred Host.
+                    }
                 }
-            }
-            if (existing)
-                await this.closeUnavailableForRecreate(existing);
-            return this.createBrowser(params);
-        });
+                if (existing)
+                    await this.closeUnavailableForRecreate(existing);
+                return this.createBrowser(params);
+            });
+        }
+        finally {
+            admission?.release();
+        }
     }
     async close(input) {
         const params = parseInput(() => parseRuntimeBrowserCloseParams(input), "Browser close request is invalid");
@@ -438,6 +446,15 @@ export class SessionBrowserService {
             throw new SessionBrowserServiceError("host_failure", "Browser Host state could not be initialized", { cause: error });
         }
     }
+    reserveOpenAdmission() {
+        if (!this.admissionReserve)
+            return undefined;
+        const admission = this.admissionReserve();
+        if (!admission) {
+            throw new SessionBrowserServiceError("shutting_down", "Browser service is shutting down");
+        }
+        return admission;
+    }
     async closeUnavailableForRecreate(record) {
         record.status = "closing";
         try {

package/dist/session-portal.d.ts

@@ -0,0 +1,42 @@
+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 interface SessionPortalAuthorization {
+    portalId: string;
+    pluginId: string;
+    scope: "plugin_sessions" | "single_session";
+    access: "read_only" | "read_write";
+    sessionId?: string;
+    expiresAt: string;
+}
+export interface SessionPortalAuthorizationPorts {
+    redeem(ticket: string): (SessionPortalAuthorization & {
+        secret: string;
+    }) | undefined;
+    authorize(portalId: string, secret: string): SessionPortalAuthorization | undefined;
+    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>;
+}
+/** 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): 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;