@rynx-ai/server 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/direct-runtime-server.js

@@ -1,7 +1,7 @@
 import { createServer, } from "node:http";
 import { decodeDirectRuntimeFrame, DIRECT_RUNTIME_CLOSE_CODE, DIRECT_RUNTIME_BROWSER_INSPECT_PATH, DIRECT_RUNTIME_BROWSER_SURFACE_PATH, DIRECT_RUNTIME_CONTROL_PATH, DIRECT_RUNTIME_MAX_HANDSHAKE_FRAME_BYTES, encodeDirectRuntimeFrame, parseServerAccepted, parseServerHello, } from "@rynx-ai/protocol/direct-runtime";
 import { createServerE2EEChannel, DIRECT_RUNTIME_E2EE_MAX_ENVELOPE_BYTES, } from "@rynx-ai/remote-runtime-e2ee";
-import { encodeRemoteRuntimeSessionEventsFrame, encodeRemoteRuntimeSessionTerminalServerFrame, encodeRemoteRuntimeRpcResponse, parseRemoteRuntimeRpcFrame, parseRemoteRuntimeSessionEventsFrame, parseRemoteRuntimeSessionTerminalClientFrame, REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_MAX_ID_CHARS, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { encodeRemoteRuntimeSessionEventsFrame, encodeRemoteRuntimeSessionTerminalServerFrame, encodeRemoteRuntimeRpcResponse, parseRemoteRuntimeRpcFrame, parseRemoteRuntimeSessionEventsFrame, parseRemoteRuntimeSessionTerminalClientFrame, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_MAX_ID_CHARS, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { encodeRuntimeEmulatorSurfaceServerFrame, parseRuntimeEmulatorSurfaceClientFrame, RUNTIME_EMULATOR_SURFACE_CHUNK_BYTES, RUNTIME_EMULATOR_SURFACE_MAX_FRAME_BYTES, } from "@rynx-ai/protocol/runtime-emulator-surface";
 import { WebSocket, WebSocketServer } from "ws";
 import { attachDirectRuntimeBrowserSurfaceServer, } from "./direct-runtime-browser-surface-server.js";
@@ -400,6 +400,9 @@ export async function startDirectRuntimeServer(options) {
             return;
         }
         if (frame.type === "session.terminal.open" ||
+            frame.type === "session.terminal.seed.read" ||
+            frame.type === "session.terminal.start" ||
+            frame.type === "session.terminal.read" ||
             frame.type === "session.terminal.input" ||
             frame.type === "session.terminal.resize" ||
             frame.type === "session.terminal.close") {
@@ -1032,66 +1035,153 @@ export async function startDirectRuntimeServer(options) {
             }
             const terminal = connection.terminal;
             if (terminal?.attachmentId === frame.attachmentId) {
-                finishTerminal(connection, terminal, "client_closed", undefined, true);
+                finishTerminal(connection, terminal, "client_closed");
             }
             else if (!connection.seenTerminalAttachmentIds.has(frame.attachmentId)) {
                 connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment id is unknown");
             }
             return;
         }
-        if (frame.type === "session.terminal.input" || frame.type === "session.terminal.resize") {
-            const terminal = connection.terminal;
-            if (!terminal || terminal.attachmentId !== frame.attachmentId || terminal.finishing) {
-                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment is not active");
+        if (frame.type === "session.terminal.open") {
+            await openTerminal(connection, frame, peer);
+            return;
+        }
+        const terminal = connection.terminal;
+        if (!terminal || terminal.attachmentId !== frame.attachmentId || terminal.finishing) {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal attachment is not active");
+            return;
+        }
+        if (terminal.seenRequestIds.has(frame.requestId)) {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal request id was already used");
+            return;
+        }
+        if (terminal.seenRequestIds.size >= limits.maxRequestIds) {
+            connection.close(CLOSE_CAPACITY, "Direct Runtime terminal request id capacity reached");
+            return;
+        }
+        terminal.seenRequestIds.add(frame.requestId);
+        let active = false;
+        try {
+            active = await options.isPeerActive(peer);
+        }
+        catch (error) {
+            options.onError?.(error, "Direct Runtime terminal peer activity check");
+        }
+        if (!active) {
+            finishTerminal(connection, terminal, "unauthorized");
+            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
+            return;
+        }
+        if (frame.type === "session.terminal.seed.read" || frame.type === "session.terminal.read") {
+            const kind = frame.type === "session.terminal.seed.read" ? "seed" : "live";
+            if (terminal.pendingPull ||
+                (kind === "seed" && terminal.phase !== "prepared") ||
+                (kind === "live" && terminal.phase !== "started")) {
+                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal pull is out of order");
                 return;
             }
-            const control = terminal.controlTail.then(async () => {
-                if (terminal.finishing)
+            terminal.pendingPull = { requestId: frame.requestId, kind };
+            const reading = kind === "seed"
+                ? terminal.attachment.readSeed(frame.offset, frame.maxBytes)
+                : terminal.attachment.read(frame.offset, frame.maxBytes);
+            void reading.then(async (result) => {
+                if (terminal.finishing || terminal.pendingPull?.requestId !== frame.requestId)
                     return;
-                let active = false;
-                try {
-                    active = await options.isPeerActive(peer);
-                }
-                catch (error) {
-                    options.onError?.(error, "Direct Runtime terminal peer activity check");
-                }
-                if (!active) {
-                    finishTerminal(connection, terminal, "unauthorized", undefined, true);
-                    connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
-                    return;
-                }
-                try {
-                    if (frame.type === "session.terminal.input") {
-                        if (terminal.attachment.role === "owner") {
-                            await terminal.attachment.write(Uint8Array.from(Buffer.from(frame.data, "base64")));
-                        }
-                    }
-                    else {
-                        await terminal.attachment.resize(frame.cols, frame.rows);
-                    }
-                }
-                catch (error) {
-                    options.onError?.(error, "Remote Session terminal control");
-                    finishTerminal(connection, terminal, "internal", "Remote Session terminal control failed", true);
-                }
+                terminal.pendingPull = undefined;
+                await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                    type: kind === "seed" ? "session.terminal.seed.chunk" : "session.terminal.chunk",
+                    attachmentId: terminal.attachmentId,
+                    requestId: frame.requestId,
+                    data: Buffer.from(result.data).toString("base64"),
+                    nextOffset: result.nextOffset,
+                    done: result.done,
+                    ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+                }), limits.maxBufferedBytes);
+            }).catch((error) => {
+                options.onError?.(error, "Remote Session terminal pull");
+                finishTerminal(connection, terminal, "internal", "Remote Session terminal pull failed");
             });
-            terminal.controlTail = control.catch(() => undefined);
-            await control;
             return;
         }
+        if (frame.type === "session.terminal.start") {
+            if (terminal.phase !== "prepared") {
+                connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal start is out of order");
+                return;
+            }
+            terminal.phase = "starting";
+            try {
+                await terminal.attachment.start();
+                terminal.phase = "started";
+                await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                    type: "session.terminal.started",
+                    attachmentId: terminal.attachmentId,
+                    requestId: frame.requestId,
+                }), limits.maxBufferedBytes);
+                void terminal.attachment.closed.then(async (closed) => {
+                    if (terminal.finishing)
+                        return;
+                    await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                        type: "session.terminal.reader.done",
+                        attachmentId: terminal.attachmentId,
+                        finalOffset: closed.finalOffset ?? 0,
+                        reason: closed.reason === "terminal_exited" ||
+                            closed.reason === "client_closed" ||
+                            closed.reason === "backpressure"
+                            ? closed.reason
+                            : "internal",
+                        exitCode: closed.exitCode ?? 0,
+                    }), limits.maxBufferedBytes);
+                }).catch((error) => {
+                    options.onError?.(error, "Remote Session terminal reader completion");
+                    finishTerminal(connection, terminal, "internal");
+                });
+            }
+            catch (error) {
+                options.onError?.(error, "Remote Session terminal start");
+                finishTerminal(connection, terminal, "internal", "Remote Session terminal start failed");
+            }
+            return;
+        }
+        if (terminal.phase !== "started") {
+            connection.close(CLOSE_BAD_PROTOCOL, "Remote Session terminal control is not writable");
+            return;
+        }
+        const control = terminal.controlTail.then(async () => {
+            if (terminal.finishing)
+                return;
+            if (frame.type === "session.terminal.input") {
+                if (terminal.attachment.role === "owner") {
+                    await terminal.attachment.write(Uint8Array.from(Buffer.from(frame.data, "base64")));
+                }
+            }
+            else {
+                await terminal.attachment.resize(frame.cols, frame.rows);
+            }
+            await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                type: frame.type === "session.terminal.input"
+                    ? "session.terminal.input.ack"
+                    : "session.terminal.resize.ack",
+                attachmentId: terminal.attachmentId,
+                requestId: frame.requestId,
+            }), limits.maxBufferedBytes);
+        });
+        terminal.controlTail = control.catch(() => undefined);
+        await control.catch((error) => {
+            options.onError?.(error, "Remote Session terminal control");
+            finishTerminal(connection, terminal, "internal", "Remote Session terminal control failed");
+        });
+    }
+    async function openTerminal(connection, frame, peer) {
         let admissionFailure;
         let pending;
-        if (connection.seenTerminalAttachmentIds.has(frame.attachmentId)) {
+        if (connection.seenTerminalAttachmentIds.has(frame.attachmentId))
             admissionFailure = "duplicate";
-        }
-        else if (connection.seenTerminalAttachmentIds.size >= limits.maxRequestIds) {
+        else if (connection.seenTerminalAttachmentIds.size >= limits.maxRequestIds)
             admissionFailure = "id_capacity";
-        }
         else {
             connection.seenTerminalAttachmentIds.add(frame.attachmentId);
-            if (connection.pendingTerminal || connection.terminal) {
+            if (connection.pendingTerminal || connection.terminal)
                 admissionFailure = "attachment_capacity";
-            }
             else {
                 pending = {
                     attachmentId: frame.attachmentId,
@@ -1100,32 +1190,9 @@ export async function startDirectRuntimeServer(options) {
                     cancelRequested: false,
                     closeFrameClaimed: false,
                 };
-                // Reserve the id before awaiting peer status or application open. A
-                // following close can now tombstone this pending attach and abort it.
                 connection.pendingTerminal = pending;
             }
         }
-        let active = false;
-        try {
-            active = await options.isPeerActive(peer);
-        }
-        catch (error) {
-            options.onError?.(error, "Direct Runtime terminal peer activity check");
-        }
-        if (!active) {
-            if (pending) {
-                connection.pendingTerminal = undefined;
-                pending.cancelRequested = true;
-                pending.abortController.abort(new Error("Remote Runtime grant is not active"));
-            }
-            if (!pending?.closeFrameClaimed) {
-                if (pending)
-                    pending.closeFrameClaimed = true;
-                await sendTerminalClosed(connection, frame.attachmentId, "unauthorized");
-            }
-            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
-            return;
-        }
         if (admissionFailure === "duplicate") {
             await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Remote Session terminal attachment id was already used");
             return;
@@ -1135,13 +1202,28 @@ export async function startDirectRuntimeServer(options) {
             return;
         }
         if (admissionFailure === "attachment_capacity") {
-            await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Direct Runtime V1 admits one Session terminal per connection");
+            await sendTerminalClosed(connection, frame.attachmentId, "capacity", "Direct Runtime admits one Session terminal per connection");
             return;
         }
         if (!pending) {
             connection.close(CLOSE_INTERNAL, "Remote Session pending terminal is unavailable");
             return;
         }
+        let active = false;
+        try {
+            active = await options.isPeerActive(peer);
+        }
+        catch (error) {
+            options.onError?.(error, "Direct Runtime terminal peer activity check");
+        }
+        if (!active) {
+            connection.pendingTerminal = undefined;
+            pending.cancelRequested = true;
+            pending.abortController.abort(new Error("Remote Runtime grant is not active"));
+            await sendTerminalClosed(connection, frame.attachmentId, "unauthorized");
+            connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
+            return;
+        }
         let opened;
         try {
             opened = await options.dispatcher.openSessionTerminal(frame.sessionId, { role: frame.role, cols: frame.cols, rows: frame.rows }, { subject: peer.subject, signal: pending.abortController.signal });
@@ -1160,14 +1242,10 @@ export async function startDirectRuntimeServer(options) {
             await sendTerminalClosed(connection, frame.attachmentId, remoteTerminalOpenCloseReason(error));
             return;
         }
-        if (pending.cancelRequested ||
-            isConnectionClosed(connection) ||
-            connection.pendingTerminal !== pending) {
+        if (pending.cancelRequested || isConnectionClosed(connection) || connection.pendingTerminal !== pending) {
             if (connection.pendingTerminal === pending)
                 connection.pendingTerminal = undefined;
-            await opened.close().catch((error) => {
-                options.onError?.(error, "Remote Session late terminal detach");
-            });
+            await opened.close().catch(() => undefined);
             if (!pending.closeFrameClaimed && !isConnectionClosed(connection)) {
                 pending.closeFrameClaimed = true;
                 await sendTerminalClosed(connection, frame.attachmentId, "client_closed");
@@ -1184,86 +1262,40 @@ export async function startDirectRuntimeServer(options) {
             attachmentId: frame.attachmentId,
             sessionId: frame.sessionId,
             attachment: opened,
-            output: new BoundedTextQueue(limits.maxQueuedTerminalOutputFrames, limits.maxQueuedTerminalOutputBytes),
+            seenRequestIds: new Set(),
+            phase: "prepared",
             controlTail: Promise.resolve(),
             finishing: false,
         };
         connection.pendingTerminal = undefined;
         connection.terminal = terminal;
-        // Drain into the bounded application queue before awaiting the opened send;
-        // output can begin synchronously with the runner attach.
-        void readTerminalOutput(connection, terminal);
-        try {
-            await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
-                type: "session.terminal.opened",
-                attachmentId: terminal.attachmentId,
-                sessionId: terminal.sessionId,
-                role: opened.role,
-            }), limits.maxBufferedBytes);
-            void writeTerminalOutput(connection, terminal);
-        }
-        catch (error) {
-            finishTerminal(connection, terminal, undefined, undefined, true);
-            throw error;
-        }
-    }
-    async function readTerminalOutput(connection, terminal) {
-        try {
-            for await (const data of terminal.attachment) {
-                if (terminal.finishing)
-                    return;
-                for (let offset = 0; offset < data.byteLength; offset += REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES) {
-                    const chunk = data.subarray(offset, Math.min(offset + REMOTE_RUNTIME_SESSION_TERMINAL_MAX_DATA_BYTES, data.byteLength));
-                    if (chunk.byteLength === 0)
-                        continue;
-                    const encoded = encodeRemoteRuntimeSessionTerminalServerFrame({
-                        type: "session.terminal.output",
-                        attachmentId: terminal.attachmentId,
-                        data: Buffer.from(chunk).toString("base64"),
-                    });
-                    if (!terminal.output.push(encoded)) {
-                        finishTerminal(connection, terminal, "backpressure", "Remote Session terminal consumer is too slow", true);
-                        return;
-                    }
-                }
-            }
-            if (terminal.finishing)
+        let lastDimensions = opened.dimensions;
+        opened.onResize?.(({ cols, rows }) => {
+            if (terminal.finishing || terminal.phase !== "started")
                 return;
-            const closed = await terminal.attachment.closed;
-            const reason = closed.reason === "terminal_exited"
-                ? "terminal_exited"
-                : closed.reason === "backpressure"
-                    ? "backpressure"
-                    : "internal";
-            finishTerminal(connection, terminal, reason, undefined, reason !== "terminal_exited", closed.exitCode);
-        }
-        catch (error) {
-            if (terminal.finishing)
+            if (lastDimensions?.cols === cols && lastDimensions.rows === rows)
                 return;
-            options.onError?.(error, "Remote Session terminal output");
-            finishTerminal(connection, terminal, "internal", "Remote Session terminal output failed", true);
-        }
-    }
-    async function writeTerminalOutput(connection, terminal) {
-        try {
-            for (;;) {
-                const frame = await terminal.output.shift();
-                if (frame === undefined)
-                    return;
-                await sendText(connection, frame, limits.maxBufferedBytes);
-            }
-        }
-        catch (error) {
-            if (!isConnectionClosed(connection)) {
-                options.onError?.(error, "Remote Session terminal delivery");
-                connection.close(CLOSE_INTERNAL, "Remote Session terminal delivery failed");
-            }
-        }
-        finally {
-            finishTerminal(connection, terminal, undefined, undefined, true);
-        }
+            lastDimensions = { cols, rows };
+            void sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+                type: "session.terminal.dimensions",
+                attachmentId: terminal.attachmentId,
+                cols,
+                rows,
+            }), limits.maxBufferedBytes).catch((error) => {
+                options.onError?.(error, "Remote Session terminal dimensions");
+                finishTerminal(connection, terminal, "internal");
+            });
+        });
+        await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
+            type: "session.terminal.prepared",
+            attachmentId: terminal.attachmentId,
+            sessionId: terminal.sessionId,
+            role: opened.role,
+            seedBytes: opened.seedBytes,
+            ...(opened.dimensions ?? {}),
+        }), limits.maxBufferedBytes);
     }
-    function finishTerminal(connection, terminal, reason, message, discardPending, exitCode) {
+    function finishTerminal(connection, terminal, reason, message, exitCode) {
         if (terminal.finishing)
             return;
         terminal.finishing = true;
@@ -1272,19 +1304,17 @@ export async function startDirectRuntimeServer(options) {
         void terminal.attachment.close().catch((error) => {
             options.onError?.(error, "Remote Session terminal detach");
         });
-        const finalFrame = reason === undefined
-            ? undefined
-            : encodeRemoteRuntimeSessionTerminalServerFrame({
+        if (reason !== undefined && !isConnectionClosed(connection)) {
+            void sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
                 type: "session.terminal.closed",
                 attachmentId: terminal.attachmentId,
                 reason,
                 ...(exitCode === undefined ? {} : { exitCode }),
                 ...(message === undefined ? {} : { message }),
+            }), limits.maxBufferedBytes).catch((error) => {
+                options.onError?.(error, "Remote Session terminal close delivery");
             });
-        if (discardPending)
-            terminal.output.replaceAndFinish(finalFrame);
-        else
-            terminal.output.finish(finalFrame);
+        }
     }
     async function sendTerminalClosed(connection, attachmentId, reason, message) {
         await sendText(connection, encodeRemoteRuntimeSessionTerminalServerFrame({
@@ -1336,6 +1366,7 @@ export async function startDirectRuntimeServer(options) {
             const accepted = parseServerAccepted(result.accepted);
             assertAuthenticationResult(serverHello, authenticate, result.peer, accepted);
             connection.peer = result.peer;
+            connection.coreProtocolVersion = accepted.coreProtocolVersion;
             const registration = connectionHub.registerWithinLimit(result.peer.grantId, connection, limits.maxConnectionsPerGrant);
             if (registration === "revoked") {
                 connection.close(CLOSE_UNAUTHORIZED, "Remote Runtime grant is not active");
@@ -1385,7 +1416,7 @@ export async function startDirectRuntimeServer(options) {
             connection.pendingTerminal = undefined;
         }
         if (connection.terminal) {
-            finishTerminal(connection, connection.terminal, undefined, undefined, true);
+            finishTerminal(connection, connection.terminal, undefined);
         }
         finalizeConnectionEmulatorSurface(connection, reason);
         if (connection.ws.readyState === WebSocket.OPEN) {
@@ -1422,7 +1453,7 @@ export async function startDirectRuntimeServer(options) {
             connection.pendingTerminal = undefined;
         }
         if (connection.terminal) {
-            finishTerminal(connection, connection.terminal, undefined, undefined, true);
+            finishTerminal(connection, connection.terminal, undefined);
         }
         finalizeConnectionEmulatorSurface(connection, "Direct Runtime connection closed");
         releaseUnauthenticatedConnection(connection);
@@ -1559,6 +1590,9 @@ function parseAuthenticatedClientFrame(bytes) {
         return frame;
     }
     if (type === "session.terminal.open" ||
+        type === "session.terminal.seed.read" ||
+        type === "session.terminal.start" ||
+        type === "session.terminal.read" ||
         type === "session.terminal.input" ||
         type === "session.terminal.resize" ||
         type === "session.terminal.close") {