@rynx-ai/server 0.1.0 → 0.1.10-beta.2

package/dist/server.js

@@ -1,19 +1,87 @@
 import { pathToFileURL } from "node:url";
 import Koa from "koa";
 import Router from "@koa/router";
-import { loadConfig, resolveRuntimeModel, ConversationRuntime, InMemorySessionBus, persistSessionEvent, } from "@rynx-ai/core";
+import { loadConfig, listAgentSpecs, loadAgentSpec, resolveSessionExecution, resolveRuntimeModel, ConversationRuntime, InMemorySessionBus, persistSessionEvent, } from "@rynx-ai/core";
 import { RunnerManager, FileCodexSessionStore, resolveCodexSessionStorePath, } from "@rynx-ai/runtime";
 import { ChannelManager } from "./channel-manager.js";
-import { createControlRouter } from "./control-api.js";
+import { createControlRouter, } from "./control-api.js";
 import { attachEmulatorTouchWs } from "./emulator-touch-ws.js";
 import { attachTerminalWs } from "./terminal-ws.js";
+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 { SessionRuntimeIndex } from "./session-runtime-index.js";
+import { createRunnerSessionTerminalHost, } from "./session-terminal-host.js";
+import { runtimeWebAccessPolicyForBindHost, } from "./runtime-web-auth.js";
 export { ChannelManager } from "./channel-manager.js";
-function toErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
+export { MachineSessionService, MachineSessionServiceFailure, MachineSessionServiceInputError, synthesizeSessionTitle, } from "./machine-session-service.js";
+export { SessionBrowserHostError, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceUnsupportedError, } from "./session-browser-service.js";
+export { SessionEmulatorBindingConflictError, SessionEmulatorService, SessionEmulatorServiceError, } from "./session-emulator-service.js";
+export { SessionBrowserSurfaceCoordinator } from "./session-browser-surface-coordinator.js";
+export { attachDesktopBrowserHostServer, createDesktopFirstSessionBrowserHost, DesktopBrowserHostAbsentError, DesktopBrowserHostProtocolError, DesktopBrowserHostRegistry, } from "./desktop-browser-host.js";
+export { createDaemonRuntimeHost, encodeDaemonStatus } from "./remote-runtime.js";
+export { DIRECT_RUNTIME_CONTROL_PATH, DirectRuntimeConnectionHub, startDirectRuntimeServer, } from "./direct-runtime-server.js";
+export { attachDirectRuntimeBrowserSurfaceServer, DirectRuntimeBrowserSurfaceHostError, } from "./direct-runtime-browser-surface-server.js";
+export { attachDirectRuntimeBrowserInspectServer, DirectRuntimeBrowserInspectHostError, } from "./direct-runtime-browser-inspect-server.js";
+export { RemoteRuntimeDispatcher } from "./remote-runtime-dispatcher.js";
+export { createRunnerSessionTerminalHost, SessionTerminalOpenError, SessionTerminalStreamError, } from "./session-terminal-host.js";
+/** Preserve one session's mirror order without serializing unrelated sessions. */
+export class SessionMirrorQueue {
+    persist;
+    tails = new Map();
+    constructor(persist) {
+        this.persist = persist;
     }
-    return "Unknown error";
+    enqueue(sessionId, event) {
+        const previous = this.tails.get(sessionId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => undefined)
+            .then(() => this.persist(sessionId, event));
+        this.tails.set(sessionId, next);
+        const cleanup = () => {
+            if (this.tails.get(sessionId) === next)
+                this.tails.delete(sessionId);
+        };
+        void next.then(cleanup, cleanup);
+        return next;
+    }
+}
+/**
+ * Compose the process-owned Session runtime once. The daemon may call this
+ * before creating its Direct dispatcher; {@link startServer} accepts the same
+ * bundle and therefore does not create a second bus, runtime index, or runner.
+ */
+export function createSessionRuntimeServices(input) {
+    const sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(input.config));
+    const runnerManager = new RunnerManager({
+        config: input.config,
+        sessionStore,
+        ...(input.sessionContextProvider
+            ? { sessionContextProvider: input.sessionContextProvider }
+            : {}),
+    });
+    const sessionBus = new InMemorySessionBus();
+    const sessionRuntimeIndex = new SessionRuntimeIndex();
+    const conversationRuntime = new ConversationRuntime({
+        config: input.config,
+        executor: runnerManager,
+        sessionBus,
+    });
+    const sessionMirrorQueue = new SessionMirrorQueue((sessionId, event) => persistSessionEvent(sessionId, event, { sessionLog: input.sessionLog, sessionBus }));
+    runnerManager.onMirror((sessionId, event) => {
+        sessionRuntimeIndex.observe(sessionId, event);
+        void sessionMirrorQueue.enqueue(sessionId, event).catch((error) => {
+            input.onMirrorError?.(error, sessionId);
+        });
+    });
+    return {
+        sessionStore,
+        runnerManager,
+        sessionBus,
+        sessionRuntimeIndex,
+        conversationRuntime,
+    };
 }
 /**
  * The HTTP surface is just a liveness probe for container orchestration — all
@@ -21,7 +89,7 @@ function toErrorMessage(error) {
  * Lark bot reaches its server over an outbound WebSocket long connection), so
  * no agent request / response / SSE endpoints are exposed here.
  */
-export function createApp({ control } = {}) {
+export function createApp({ config = loadConfig(), control } = {}) {
     const app = new Koa();
     const router = new Router();
     router.get("/health", (ctx) => {
@@ -30,16 +98,24 @@ export function createApp({ control } = {}) {
     app.use(router.routes());
     app.use(router.allowedMethods());
     if (control) {
-        const controlRouter = createControlRouter(control);
+        const controlRouter = createControlRouter({
+            ...control,
+            runtimeWebAccess: control.runtimeWebAccess ??
+                runtimeWebAccessPolicyForBindHost(config.HOST),
+        });
         app.use(controlRouter.routes());
         app.use(controlRouter.allowedMethods());
-        // Serve the built control-web SPA for everything that isn't /health or /api.
+    }
+    if (control) {
+        // Serve the built control-web SPA outside the server-owned health, API, and
+        // one-shot control-link namespaces.
         const distDir = resolveControlWebDist();
         app.use(async (ctx, next) => {
             if (ctx.method !== "GET" && ctx.method !== "HEAD")
                 return next();
-            if (ctx.path === "/health" || ctx.path.startsWith("/api/"))
+            if (["/health", "/api", "/control"].some((prefix) => ctx.path === prefix || ctx.path.startsWith(`${prefix}/`))) {
                 return next();
+            }
             if (!distDir) {
                 if (ctx.path === "/") {
                     ctx.type = "html";
@@ -55,46 +131,66 @@ export function createApp({ control } = {}) {
     }
     return app;
 }
-export async function startServer({ config = loadConfig(), channelFactories = [], channelInstances, loadInstances, control, sessionLog, sessionRegistry, } = {}) {
-    // One shared session store, owned here and handed to the channels via the
-    // ChannelContext (mirror index / active-session reads). Runner children open
-    // the same on-disk store for their session bindings.
-    const sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config));
-    // The executor + capability surface. Holds no execution backend itself: it
-    // spawns a runner child per session for turns, forwards per-thread
-    // capabilities to a runner, and answers status/model-list locally.
-    const runnerManager = new RunnerManager({
+export async function startServer({ config = loadConfig(), channelInstances, loadInstances, control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, } = {}) {
+    const runtimeWebAccess = runtimeWebAccessPolicyForBindHost(config.HOST);
+    const desktopBrowserManagementToken = desktopBrowserHost
+        ? requireDaemonManagementToken(daemonManagement)
+        : undefined;
+    const sessionServices = sessionRuntimeServices ?? createSessionRuntimeServices({
         config,
-        sessionStore,
-        // Give runner children the control-plane URL so a claude-native
-        // PermissionRequest hook subprocess can POST approvals back to this daemon.
-        childEnv: {
-            RYNX_CONTROL_URL: `http://127.0.0.1:${config.PORT}`,
+        sessionLog,
+        onMirrorError: (error, sessionId) => {
+            console.error(`[session-mirror] session=${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
         },
     });
-    // One canonical event bus shared by every mounted instance, so a future
-    // observer (web console) sees every channel's turns over one fan-out.
-    const sessionBus = new InMemorySessionBus();
-    const conversationRuntime = new ConversationRuntime({
-        config,
-        executor: runnerManager,
-        // The live co-drive path (`runLive`) reads a turn's mirrored events off this bus.
-        sessionBus,
-    });
-    // codex-native single-writer: a session's persistent forwarder mirrors EVERY
-    // turn (web- AND co-driving-TUI-initiated) as canonical SessionEvents; persist
-    // + publish each so the web console's /stream renders them uniformly.
-    runnerManager.onMirror((sessionId, event) => {
-        void persistSessionEvent(sessionId, event, { sessionLog, sessionBus });
-    });
+    const { sessionStore, runnerManager, sessionBus, sessionRuntimeIndex, conversationRuntime, } = sessionServices;
+    const legacyLocalTerminalHost = sessionTerminals ??
+        createRunnerSessionTerminalHost({
+            runnerManager,
+            resolveLiveSession: async (sessionId) => {
+                const session = await sessionStore.get(sessionId);
+                if (!session || !runnerManager.hasLiveSession(sessionId))
+                    return undefined;
+                return { cwd: session.cwd };
+            },
+        });
+    if (pluginRuntime) {
+        if (!sessionRegistry)
+            throw new Error("plugin runtime requires a machine session registry");
+        pluginRuntime.bindHostServices({
+            conversationRuntime,
+            capabilities: runnerManager,
+            sessionStore,
+            sessionRegistry,
+            agentCatalog: {
+                list: async () => (await listAgentSpecs()).map(toPluginAgentSummary),
+                get: async (id) => {
+                    const spec = await loadAgentSpec(id);
+                    return spec ? toPluginAgentSummary(spec) : null;
+                },
+                resolveExecution: (input) => resolveSessionExecution({
+                    config,
+                    ...(input.defaultAgent ? { defaultAgent: input.defaultAgent } : {}),
+                    session: input.session,
+                }),
+            },
+            interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
+            resolveSessionInteraction: (sessionId, interactionId, resolution) => runnerManager.resolveInteraction(sessionId, interactionId, resolution),
+        });
+    }
     // claude `/clear`·`/fork` rotates to a fresh machine-session; record its meta so
-    // the console list shows it with the carried-over agent/model + a source tag.
+    // the console list shows it with the carried-over launch target/model + a source tag.
     // (It also surfaces via the log-merge once its first turn mirrors.)
     runnerManager.onRotate((r) => {
+        const source = control?.getSessionMeta(r.from);
         control?.createSessionMeta({
             id: r.to,
             source: r.kind === "fork" ? "fork" : "clear",
-            ...(r.agent ? { agent: r.agent } : {}),
+            ...(r.agent
+                ? { agent: r.agent }
+                : source?.provider
+                    ? { provider: source.provider }
+                    : {}),
             ...(r.model ? { model: r.model } : {}),
             createdAt: new Date().toISOString(),
         });
@@ -103,6 +199,7 @@ export async function startServer({ config = loadConfig(), channelFactories = []
     // `loadInstances`; the control plane drives live start/stop/reload).
     const resolveInstances = loadInstances ?? (channelInstances ? async () => channelInstances : null);
     if (resolveInstances) {
+        const controlShutdown = new AbortController();
         const manager = new ChannelManager({
             config,
             conversationRuntime,
@@ -124,6 +221,27 @@ export async function startServer({ config = loadConfig(), channelFactories = []
                     sessionLog,
                     runnerManager,
                     sessionStore,
+                    pluginRuntimeStatus: pluginRuntime
+                        ? () => pluginRuntime.statusSnapshot()
+                        : undefined,
+                    pluginRuntimeReload: pluginRuntime
+                        ? (pluginId) => pluginRuntime.reloadPluginRuntime(pluginId)
+                        : undefined,
+                    pluginRuntimeEnsure: pluginRuntime
+                        ? (pluginId) => pluginRuntime.ensurePluginRuntime(pluginId)
+                        : undefined,
+                    daemonManagement,
+                    remoteRuntime,
+                    remoteRuntimeAdmin,
+                    runtimeTargetControl,
+                    runtimeConnectionResolver,
+                    localSessionResources,
+                    sessionEmulators,
+                    shutdownSignal: controlShutdown.signal,
+                    sessionRuntimeIndex,
+                    sessionLifecycle,
+                    runtimeLocalBrowser,
+                    providerClis,
                 }
                 : undefined,
         });
@@ -137,44 +255,59 @@ export async function startServer({ config = loadConfig(), channelFactories = []
                     runtime: config.AGENT_RUNTIME,
                     model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
                 }));
-                void manager.startAll();
-                // Live WS bridges share this http.Server (no second port).
-                attachTerminalWs(server, { runnerManager });
-                if (control?.emulator)
-                    attachEmulatorTouchWs(server, { emulator: control.emulator });
-                server.on("close", () => {
-                    void manager.stopAll();
-                    void runnerManager.stop();
+                const startup = (async () => {
+                    await pluginRuntime?.startPluginRuntimes();
+                    await manager.startAll();
+                })();
+                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(server);
+                // Live WS bridges share this http.Server (no second port).
+                const webSocketServers = [
+                    attachTerminalWs(server, {
+                        runtimeConnectionResolver,
+                        legacyLocalTerminalHost,
+                        runtimeWebAccess,
+                    }),
+                    attachBrowserSurfaceWs(server, { runtimeConnectionResolver, runtimeWebAccess }),
+                    attachEmulatorSurfaceWs(server, { runtimeConnectionResolver, runtimeWebAccess }),
+                ];
+                if (desktopBrowserHost && desktopBrowserManagementToken) {
+                    webSocketServers.push(attachDesktopBrowserHostServer(server, {
+                        ...desktopBrowserHost,
+                        managementToken: desktopBrowserManagementToken,
+                    }));
+                }
+                if (control?.emulator) {
+                    webSocketServers.push(attachEmulatorTouchWs(server, { emulator: control.emulator }));
+                }
+                resolve(bindServerLifecycle(server, {
+                    fence: () => {
+                        controlShutdown.abort(new Error("Rynx server is shutting down"));
+                    },
+                    closeUpgrades: async () => {
+                        await closeWebSocketServers(webSocketServers);
+                    },
+                    cleanup: async () => {
+                        await runCleanupSteps([
+                            () => startup.catch(() => undefined),
+                            () => manager.stopAll(),
+                            () => Promise.resolve(daemonManagement?.pluginManagement?.dispose?.()),
+                            () => pluginRuntime?.dispose() ?? Promise.resolve(),
+                            () => runnerManager.stop(),
+                        ]);
+                    },
+                }));
             });
         });
     }
-    // Legacy path: one shared context for all factories (unchanged behavior).
-    const channelContext = {
-        config,
-        conversationRuntime,
-        capabilities: runnerManager,
-        sessionStore,
-    };
-    // Construct each channel defensively: a plugin that throws while building
-    // (e.g. Lark with missing credentials) is isolated and logged, so one broken
-    // channel can't take down the host or its sibling channels.
-    const channels = [];
-    for (const factory of channelFactories) {
-        try {
-            channels.push(factory(channelContext));
-        }
-        catch (error) {
-            console.error(JSON.stringify({
-                level: "error",
-                type: "channel",
-                event: "construct_failed",
-                error: toErrorMessage(error),
-            }));
-        }
-    }
-    const app = createApp({ config });
+    // Core-only mode: no chat instances and no plugin code are required.
+    const app = createApp();
     return new Promise((resolve) => {
         const server = app.listen(config.PORT, config.HOST, () => {
             console.log(JSON.stringify({
@@ -184,37 +317,145 @@ export async function startServer({ config = loadConfig(), channelFactories = []
                 port: config.PORT,
                 runtime: config.AGENT_RUNTIME,
                 model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
-                channels: channels.map((channel) => channel.id),
             }));
-            for (const channel of channels) {
-                void channel.start().catch((error) => {
-                    console.error(JSON.stringify({
-                        level: "error",
-                        type: "channel",
-                        channel: channel.id,
-                        event: "runtime.start_failed",
-                        error: toErrorMessage(error),
-                    }));
-                });
+            const webSocketServers = [];
+            if (desktopBrowserHost && desktopBrowserManagementToken) {
+                webSocketServers.push(attachDesktopBrowserHostServer(server, {
+                    ...desktopBrowserHost,
+                    managementToken: desktopBrowserManagementToken,
+                }));
             }
-            server.on("close", () => {
-                void runnerManager.stop();
-                for (const channel of channels) {
-                    void channel.stop().catch((error) => {
-                        console.error(JSON.stringify({
-                            level: "error",
-                            type: "channel",
-                            channel: channel.id,
-                            event: "runtime.stop_failed",
-                            error: toErrorMessage(error),
-                        }));
-                    });
-                }
+            resolve(bindServerLifecycle(server, {
+                ...(webSocketServers.length > 0
+                    ? { closeUpgrades: () => closeWebSocketServers(webSocketServers) }
+                    : {}),
+                cleanup: () => runnerManager.stop(),
+            }));
+        });
+    });
+}
+function requireDaemonManagementToken(host) {
+    const token = host?.managementToken;
+    const bytes = typeof token === "string" ? Buffer.byteLength(token, "utf8") : 0;
+    if (bytes < 32 || bytes > 256) {
+        throw new Error("Desktop Browser Host requires configured daemon management auth");
+    }
+    return token;
+}
+function bindServerLifecycle(server, lifecycle) {
+    let closed = false;
+    let acceptanceClosePromise;
+    let shutdownPromise;
+    const nativeClose = server.close.bind(server);
+    server.once("close", () => {
+        closed = true;
+    });
+    const managed = server;
+    managed.stopAccepting = () => {
+        if (acceptanceClosePromise)
+            return;
+        lifecycle.fence?.();
+        acceptanceClosePromise = closeHttpServer(server, nativeClose, () => closed);
+        // The full shutdown joins this promise immediately; retain a rejection
+        // handler so a caller cannot create an unhandled rejection in between.
+        void acceptanceClosePromise.catch(() => undefined);
+    };
+    managed.shutdown = () => {
+        if (shutdownPromise)
+            return shutdownPromise;
+        managed.stopAccepting();
+        shutdownPromise = (async () => {
+            // Stop accepting first, close upgraded sockets so they cannot hold the
+            // HTTP drain open, then keep runtime dependencies alive until every
+            // in-flight HTTP request has completed.
+            const closeResult = acceptanceClosePromise;
+            const upgradeResult = lifecycle.closeUpgrades?.() ?? Promise.resolve();
+            const drainResults = await Promise.allSettled([upgradeResult, closeResult]);
+            const errors = drainResults
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            try {
+                await lifecycle.cleanup();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (errors.length > 0)
+                throw new AggregateError(errors, "Rynx server shutdown failed");
+        })();
+        return shutdownPromise;
+    };
+    managed.close = ((callback) => {
+        const completion = managed.shutdown();
+        if (callback) {
+            void completion.then(() => callback(), (error) => callback(asError(error)));
+        }
+        else {
+            void completion.catch((error) => {
+                console.error(JSON.stringify({
+                    level: "error",
+                    type: "shutdown",
+                    event: "cleanup_failed",
+                    error: error instanceof Error ? error.message : String(error),
+                }));
             });
-            resolve(server);
+        }
+        return managed;
+    });
+    return managed;
+}
+async function closeHttpServer(server, nativeClose, isClosed) {
+    if (isClosed())
+        return;
+    if (!server.listening) {
+        await new Promise((resolve) => server.once("close", resolve));
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        nativeClose((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
         });
     });
 }
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+async function runCleanupSteps(steps) {
+    const errors = [];
+    for (const step of steps) {
+        try {
+            await step();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length > 0)
+        throw new AggregateError(errors, "Rynx resource cleanup failed");
+}
+async function closeWebSocketServers(servers) {
+    await Promise.all(servers.map((server) => new Promise((resolve, reject) => {
+        for (const client of server.clients)
+            client.terminate();
+        server.close((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    })));
+}
+function toPluginAgentSummary(spec) {
+    return {
+        id: spec.id,
+        ...(spec.name ? { name: spec.name } : {}),
+        ...(spec.executor?.runtime ? { runtime: spec.executor.runtime } : {}),
+        ...(spec.executor?.model ? { model: spec.executor.model } : {}),
+    };
+}
 const entrypoint = process.argv[1];
 if (entrypoint && import.meta.url === pathToFileURL(entrypoint).href) {
     startServer().catch((error) => {