@rynx-ai/server 0.1.9 → 0.1.10-beta.3

package/dist/direct-runtime-server.d.ts

@@ -4,6 +4,7 @@ import { type RuntimeEmulatorSurfaceClientFrame, type RuntimeEmulatorSurfaceOpen
 import { WebSocket } from "ws";
 import { type AuthenticatedRuntimeSubject, type RemoteRuntimeDispatcher } from "./remote-runtime-dispatcher.js";
 import { type DirectRuntimeBrowserSurfaceHost, type DirectRuntimeBrowserSurfaceServerLimits } from "./direct-runtime-browser-surface-server.js";
+import { type DirectRuntimeBrowserInspectHost, type DirectRuntimeBrowserInspectServerLimits } from "./direct-runtime-browser-inspect-server.js";
 export { DIRECT_RUNTIME_CONTROL_PATH };
 export interface DirectRuntimeAuthenticator {
     createServerHello(input: {
@@ -87,6 +88,11 @@ export interface StartDirectRuntimeServerOptions {
         host: DirectRuntimeBrowserSurfaceHost;
         limits?: Partial<Pick<DirectRuntimeBrowserSurfaceServerLimits, "maxQueuedFrames" | "maxBufferedBytes" | "peerLivenessTimeoutMs">>;
     };
+    /** Optional dedicated V4 transparent Browser Inspect transport. */
+    browserInspect?: {
+        host: DirectRuntimeBrowserInspectHost;
+        limits?: Partial<Pick<DirectRuntimeBrowserInspectServerLimits, "maxQueuedBytes" | "maxBufferedBytes" | "peerLivenessTimeoutMs">>;
+    };
     /** Session-owned Emulator frames on a dedicated authenticated control connection. */
     emulatorSurface?: {
         host: DirectRuntimeEmulatorSurfaceHost;

package/dist/direct-runtime-server.js

@@ -1,10 +1,11 @@
 import { createServer, } from "node:http";
-import { decodeDirectRuntimeFrame, DIRECT_RUNTIME_CLOSE_CODE, 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 { 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 { 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";
+import { attachDirectRuntimeBrowserInspectServer, } from "./direct-runtime-browser-inspect-server.js";
 export { DIRECT_RUNTIME_CONTROL_PATH };
 const CLOSE_BAD_PROTOCOL = DIRECT_RUNTIME_CLOSE_CODE.badProtocol;
 const CLOSE_UNAUTHORIZED = DIRECT_RUNTIME_CLOSE_CODE.unauthorized;
@@ -149,6 +150,28 @@ export async function startDirectRuntimeServer(options) {
             onError: options.onError,
         })
         : undefined;
+    const browserInspectServer = options.browserInspect
+        ? attachDirectRuntimeBrowserInspectServer(server, {
+            e2ee: options.e2ee,
+            authenticator: options.authenticator,
+            host: options.browserInspect.host,
+            isPeerActive: options.isPeerActive,
+            connectionHub,
+            limits: {
+                ...options.browserInspect.limits,
+                authenticationTimeoutMs: limits.authenticationTimeoutMs,
+                maxConnections: limits.maxConnections,
+                maxUnauthenticatedConnectionsPerSource: limits.maxUnauthenticatedConnectionsPerSource,
+                maxAuthenticationAttemptsPerSource: limits.maxAuthenticationAttemptsPerSource,
+                authenticationAttemptWindowMs: limits.authenticationAttemptWindowMs,
+                maxTrackedAuthenticationSources: limits.maxTrackedAuthenticationSources,
+                maxConnectionsPerGrant: limits.maxConnectionsPerGrant,
+                heartbeatIntervalMs: limits.heartbeatIntervalMs,
+                shutdownDeadlineMs: limits.shutdownDeadlineMs,
+            },
+            onError: options.onError,
+        })
+        : undefined;
     server.on("upgrade", (request, socket, head) => {
         const sourceAddress = socketSourceAddress(request);
         if (stopping) {
@@ -158,6 +181,9 @@ export async function startDirectRuntimeServer(options) {
         if (browserSurfaceServer && request.url === DIRECT_RUNTIME_BROWSER_SURFACE_PATH) {
             return;
         }
+        if (browserInspectServer && request.url === DIRECT_RUNTIME_BROWSER_INSPECT_PATH) {
+            return;
+        }
         if (request.url !== DIRECT_RUNTIME_CONTROL_PATH) {
             rejectUpgrade(socket, 404, "Direct Runtime route not found");
             return;
@@ -1468,6 +1494,7 @@ export async function startDirectRuntimeServer(options) {
         }
         const deadline = Date.now() + limits.shutdownDeadlineMs;
         const browserSurfaceClosed = browserSurfaceServer?.shutdown() ?? Promise.resolve();
+        const browserInspectClosed = browserInspectServer?.shutdown() ?? Promise.resolve();
         const httpClosed = closeHttpServer(server);
         const shutdownReason = new Error("Direct Runtime server is shutting down");
         for (const controller of activeDispatchControllers)
@@ -1481,6 +1508,7 @@ export async function startDirectRuntimeServer(options) {
         const drained = Promise.all([
             httpClosed,
             browserSurfaceClosed,
+            browserInspectClosed,
             waitForConnectionsEmpty(allConnections, emptyWaiters),
             Promise.allSettled([...activeDispatches]),
         ]);

package/dist/emulator-surface-ws.d.ts

@@ -1,6 +1,8 @@
 import type { Server } from "node:http";
 import { WebSocketServer } from "ws";
+import { type RuntimeWebAccessPolicy } from "./runtime-web-auth.js";
 import type { RuntimeConnectionResolverHost } from "./server.js";
 export declare function attachEmulatorSurfaceWs(server: Server, deps: {
     runtimeConnectionResolver?: RuntimeConnectionResolverHost;
+    runtimeWebAccess?: RuntimeWebAccessPolicy;
 }): WebSocketServer;

package/dist/emulator-surface-ws.js

@@ -19,6 +19,7 @@ export function attachEmulatorSurfaceWs(server, deps) {
         const authorization = authorizeRuntimeWebRequest(request, {
             mutation: true,
             capability: parsed.url.searchParams.get(RUNTIME_WEB_CAPABILITY_QUERY) ?? "",
+            access: deps.runtimeWebAccess,
         });
         if (authorization)
             return rejectUpgrade(socket, authorization.status, authorization.error);

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

@@ -7,8 +7,9 @@
  * Direct adapters can therefore expose the same behavior without copying state
  * into a Control Plane database.
  */
-import { type AgentRuntimeId, type AgentSpec, type ConversationRuntime, type SessionProviderId, type ReasoningEffort, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
-import type { SequencedSessionEvent, SessionInteractionResolution, SessionItem } from "@rynx-ai/protocol";
+import { type AgentRuntimeId, type AgentSpec, type ConversationRuntime, type SessionProviderId, type ReasoningEffort, type RuntimeUserInput, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
+import type { SequencedSessionEvent, SessionInteractionResolution, SessionItem, UserContentPart } from "@rynx-ai/protocol";
+import type { RemoteRuntimeSessionResourceDeleteParams, RemoteRuntimeSessionResourceDeleteResult, RemoteRuntimeSessionResourceGetParams, RemoteRuntimeSessionResourceGetResult, RemoteRuntimeSessionResourcePolicyResult, RemoteRuntimeSessionResourceReadParams, RemoteRuntimeSessionResourceReadResult, RemoteRuntimeSessionResourceUploadBeginParams, RemoteRuntimeSessionResourceUploadBeginResult, RemoteRuntimeSessionResourceUploadChunkParams, RemoteRuntimeSessionResourceUploadChunkResult, RemoteRuntimeSessionResourceUploadCommitParams, RemoteRuntimeSessionResourceUploadCommitResult } from "@rynx-ai/protocol/remote-runtime-rpc";
 import type { ControlAgentSummary, ControlSessionInteractionResolveDisposition, ControlSessionRuntimeSnapshot } from "@rynx-ai/protocol/control";
 import { type RemoteRuntimeSessionInterruptResult, type RemoteRuntimeSessionLaunchOptionsListResult, type RemoteRuntimeSessionListParams, type RemoteRuntimeSessionListResult, type RemoteRuntimeSessionSnapshotParams } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { type CodexRuntimeStatus, type CodexSessionStore, type InjectOutcome } from "@rynx-ai/runtime";
@@ -22,6 +23,44 @@ export interface MachineSessionInterruptPort {
 export interface MachineSessionAgentCatalogPort {
     list(): Promise<ControlAgentSummary[]>;
 }
+export interface MachineSessionPendingMessage {
+    sessionId: string;
+    message: string;
+    createdAt: string;
+    state: "queued" | "outcome_unknown";
+}
+/** Durable one-message admission queue used while a Provider needs setup. */
+export interface MachineSessionPendingMessagePort {
+    put(message: Omit<MachineSessionPendingMessage, "state">): boolean | Promise<boolean>;
+    get(sessionId: string): MachineSessionPendingMessage | undefined | Promise<MachineSessionPendingMessage | undefined>;
+    list(): MachineSessionPendingMessage[] | Promise<MachineSessionPendingMessage[]>;
+    markOutcomeUnknown(sessionId: string): void | Promise<void>;
+    delete(sessionId: string): void | Promise<void>;
+}
+export type MachineSessionMessageOperationState = "prepared" | "injecting" | "injected" | "mirrored" | "outcome_unknown" | "failed_not_started";
+export interface MachineSessionPreparedInput {
+    input: RuntimeUserInput;
+    title: string;
+    operationState?: MachineSessionMessageOperationState;
+}
+/** Target-daemon resource authority. Transfer methods are deliberately chunked
+ * below the 64 KiB Direct Runtime frame; `prepareInput` is the only method that
+ * can turn opaque browser-visible ids into runtime-local file paths. */
+export interface MachineSessionResourcePort {
+    policy(sessionId: string): RemoteRuntimeSessionResourcePolicyResult;
+    beginUpload(input: RemoteRuntimeSessionResourceUploadBeginParams): Promise<RemoteRuntimeSessionResourceUploadBeginResult>;
+    writeUploadChunk(input: RemoteRuntimeSessionResourceUploadChunkParams): Promise<RemoteRuntimeSessionResourceUploadChunkResult>;
+    commitUpload(input: RemoteRuntimeSessionResourceUploadCommitParams): Promise<RemoteRuntimeSessionResourceUploadCommitResult>;
+    getResource(input: RemoteRuntimeSessionResourceGetParams): Promise<RemoteRuntimeSessionResourceGetResult>;
+    readResource(input: RemoteRuntimeSessionResourceReadParams): Promise<RemoteRuntimeSessionResourceReadResult>;
+    deleteResource(input: RemoteRuntimeSessionResourceDeleteParams): Promise<RemoteRuntimeSessionResourceDeleteResult>;
+    prepareInput(sessionId: string, content: UserContentPart[], clientMessageId?: string): Promise<MachineSessionPreparedInput>;
+    markMessageInjecting(sessionId: string, clientMessageId: string): void | Promise<void>;
+    markMessageInjected(sessionId: string, clientMessageId: string): void | Promise<void>;
+    markMessageOutcomeUnknown(sessionId: string, clientMessageId: string, reason: string): void | Promise<void>;
+    markMessageFailedNotStarted(sessionId: string, clientMessageId: string, reason: string): void | Promise<void>;
+    deleteSession(sessionId: string): void | Promise<void>;
+}
 export interface MachineSessionRunnerPort {
     ensureLiveSession(sessionId: string, options?: {
         cwd?: string;
@@ -32,8 +71,18 @@ export interface MachineSessionRunnerPort {
         agentName?: string;
         agentSpec?: AgentSpec;
     }): Promise<boolean>;
+    /** Start the Provider TUI pane without waiting for its native thread to bind. */
+    startLiveSession?(sessionId: string, options?: {
+        cwd?: string;
+        cols?: number;
+        rows?: number;
+        runtime?: AgentRuntimeId;
+        reasoningEffort?: ReasoningEffort;
+        agentName?: string;
+        agentSpec?: AgentSpec;
+    }): Promise<boolean>;
     lastLiveSessionError?(sessionId: string): string | undefined;
-    injectMessage(sessionId: string, text: string): Promise<InjectOutcome>;
+    injectMessage(sessionId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
     stopRunner(sessionId: string): void;
     resolveInteraction(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: ControlSessionInteractionResolveDisposition;
@@ -56,6 +105,9 @@ export interface MachineSessionServicePorts {
     };
     /** Target-daemon catalog. Exposed only as bounded Session creation options. */
     agents?: MachineSessionAgentCatalogPort;
+    /** Durable first messages that must not reach a Provider setup prompt. */
+    pendingMessages?: MachineSessionPendingMessagePort;
+    resources?: MachineSessionResourcePort;
     /** Native Session execution belongs to the target daemon, never the caller. */
     execution?: {
         runtime: Pick<ConversationRuntime, "resolveRuntime">;
@@ -74,6 +126,8 @@ export interface MachineSessionServiceOptions {
     snapshotPageMaxBytes?: number;
     /** Bound for the current registry/log merge until storage offers keyset paging. */
     directoryScanLimit?: number;
+    /** Delay between setup-readiness retries for durable pending messages. */
+    pendingMessageRetryMs?: number;
 }
 export type MachineSessionListInput = RemoteRuntimeSessionListParams;
 export interface MachineSessionListPage extends RemoteRuntimeSessionListResult {
@@ -109,6 +163,15 @@ export interface MachineSessionMessageResult {
     ok: true;
     injected: true;
 }
+export interface MachineSessionMessageInput {
+    message?: string;
+    content?: UserContentPart[];
+    clientMessageId?: string;
+}
+export interface MachineSessionMessageEnqueueResult {
+    ok: true;
+    queued: true;
+}
 export interface MachineSessionTerminalStartResult {
     ok: true;
 }
@@ -130,7 +193,7 @@ export interface MachineSessionWatch extends AsyncIterable<SequencedSessionEvent
 export declare class MachineSessionServiceInputError extends Error {
     constructor(message: string);
 }
-export type MachineSessionServiceFailureCode = "not_found" | "failed_precondition" | "outcome_unknown";
+export type MachineSessionServiceFailureCode = "not_found" | "failed_precondition" | "conflict" | "outcome_unknown";
 /** Expected application failure; adapters decide how to represent it on the wire. */
 export declare class MachineSessionServiceFailure extends Error {
     readonly code: MachineSessionServiceFailureCode;
@@ -145,6 +208,9 @@ export declare class MachineSessionService {
     private readonly maxSnapshotItemLimit;
     private readonly snapshotPageMaxBytes;
     private readonly directoryScanLimit;
+    private readonly pendingMessageRetryMs;
+    private readonly pendingDeliveries;
+    private readonly cancelledPendingDeliveries;
     constructor(ports: MachineSessionServicePorts, options?: MachineSessionServiceOptions);
     list(input?: MachineSessionListInput): Promise<MachineSessionListPage>;
     snapshot(input: MachineSessionSnapshotInput): Promise<MachineSessionSnapshotPage>;
@@ -166,13 +232,30 @@ export declare class MachineSessionService {
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     create(input: MachineSessionCreateInput): Promise<MachineSessionCreateResult>;
     /** Inject one turn through the target daemon's native single-writer runner. */
-    sendMessage(sessionIdInput: string, messageInput: string): Promise<MachineSessionMessageResult>;
+    sendMessage(sessionIdInput: string, messageInput: string | MachineSessionMessageInput): Promise<MachineSessionMessageResult>;
+    resourcePolicy(sessionIdInput: string): RemoteRuntimeSessionResourcePolicyResult;
+    beginResourceUpload(input: RemoteRuntimeSessionResourceUploadBeginParams): Promise<RemoteRuntimeSessionResourceUploadBeginResult>;
+    writeResourceUploadChunk(input: RemoteRuntimeSessionResourceUploadChunkParams): Promise<RemoteRuntimeSessionResourceUploadChunkResult>;
+    commitResourceUpload(input: RemoteRuntimeSessionResourceUploadCommitParams): Promise<RemoteRuntimeSessionResourceUploadCommitResult>;
+    getResource(input: RemoteRuntimeSessionResourceGetParams): Promise<RemoteRuntimeSessionResourceGetResult>;
+    readResource(input: RemoteRuntimeSessionResourceReadParams): Promise<RemoteRuntimeSessionResourceReadResult>;
+    deleteResource(input: RemoteRuntimeSessionResourceDeleteParams): Promise<RemoteRuntimeSessionResourceDeleteResult>;
+    /** Persist the first task while login/onboarding owns the Provider TUI. The
+     * delivery worker starts the pane now, waits for a real native thread, then
+     * injects exactly once. `failed` is fenced as outcome_unknown and never retried. */
+    enqueueMessage(sessionIdInput: string, messageInput: string): Promise<MachineSessionMessageEnqueueResult>;
     /** Explicitly restore the target daemon's live runner without starting a turn. */
     startTerminal(sessionIdInput: string): Promise<MachineSessionTerminalStartResult>;
     private ensureLiveSession;
+    private liveSessionRequest;
     resolveInteraction(sessionIdInput: string, interactionIdInput: string, resolution: SessionInteractionResolution): Promise<MachineSessionInteractionResult>;
     delete(sessionIdInput: string): Promise<MachineSessionDeleteResult>;
     private requireAgents;
+    private requireResources;
+    private requireResourceSession;
+    private resumePendingDeliveries;
+    private schedulePendingDelivery;
+    private deliverPendingMessage;
     private runtimeReadiness;
     private probeRuntimeReadiness;
     private requireExecution;