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

package/dist/server.js

@@ -1,19 +1,24 @@
+import { basename, extname, isAbsolute } from "node:path";
 import { pathToFileURL } from "node:url";
 import Koa from "koa";
 import Router from "@koa/router";
 import { loadConfig, listAgentSpecs, loadAgentSpec, resolveSessionExecution, resolveRuntimeModel, ConversationRuntime, InMemorySessionBus, persistSessionEvent, } from "@rynx-ai/core";
 import { RunnerManager, FileCodexSessionStore, resolveCodexSessionStorePath, } from "@rynx-ai/runtime";
 import { createControlRouter, } from "./control-api.js";
+import { MachineSessionServiceFailure, MachineSessionServiceInputError, } from "./machine-session-service.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 { 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";
 export { MachineSessionService, MachineSessionServiceFailure, MachineSessionServiceInputError, synthesizeSessionTitle, } from "./machine-session-service.js";
+export { SessionPendingInputIndex } from "./session-pending-inputs.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";
@@ -25,25 +30,74 @@ export { attachDirectRuntimeBrowserInspectServer, DirectRuntimeBrowserInspectHos
 export { RemoteRuntimeDispatcher } from "./remote-runtime-dispatcher.js";
 export { createRunnerSessionTerminalHost, SessionTerminalOpenError, SessionTerminalStreamError, } from "./session-terminal-host.js";
 export { listRuntimeModels } from "@rynx-ai/runtime";
-/** Preserve one session's mirror order without serializing unrelated sessions. */
+/** Bound one mirror write at ten seconds. After that uncertainty boundary,
+ * later records may start instead
+ * of waiting forever behind a persistence call whose result is unknown. */
+const SESSION_MIRROR_STALL_TIMEOUT_MS = 10_000;
+class SessionMirrorAmbiguousError extends Error {
+    abandonToken;
+    mirrorClassification = "ambiguous";
+    constructor(sessionId, abandonToken) {
+        super(`Session mirror persistence did not settle before its response deadline: ${sessionId}`);
+        this.abandonToken = abandonToken;
+        this.name = "SessionMirrorAmbiguousError";
+    }
+}
+function preparedMirrorPersistence(persistence) {
+    if (typeof persistence === "object" &&
+        persistence !== null &&
+        "promise" in persistence)
+        return persistence;
+    return { promise: persistence };
+}
+/** Preserve one session's mirror order without serializing unrelated sessions.
+ * A timed-out operation is not cancelled: like an HTTP read timeout, it may
+ * still commit later. Its caller receives `ambiguous` and must not retry. */
 export class SessionMirrorQueue {
     persist;
+    stallTimeoutMs;
     tails = new Map();
-    constructor(persist) {
+    constructor(persist, stallTimeoutMs = SESSION_MIRROR_STALL_TIMEOUT_MS) {
         this.persist = persist;
+        this.stallTimeoutMs = stallTimeoutMs;
     }
     enqueue(sessionId, event) {
         const previous = this.tails.get(sessionId) ?? Promise.resolve();
-        const next = previous
+        const bounded = previous
             .catch(() => undefined)
-            .then(() => this.persist(sessionId, event));
-        this.tails.set(sessionId, next);
+            .then(() => {
+            // Prepare only when this record reaches the head of its Session lane.
+            // Starting either persistence or its deadline while an older record is
+            // still ahead would shorten queued records' attempt windows and allow a
+            // burst of them to time out concurrently.
+            const prepared = preparedMirrorPersistence(this.persist(sessionId, event));
+            let timer;
+            return new Promise((resolve, reject) => {
+                timer = setTimeout(() => {
+                    // A user echo claims one exact optimistic pending input while the
+                    // write starts. Retire it synchronously before rejecting this tail:
+                    // the next echo must never peek the same content or attachments.
+                    prepared.onAmbiguous?.();
+                    reject(new SessionMirrorAmbiguousError(sessionId, prepared.abandonToken));
+                }, this.stallTimeoutMs);
+                timer.unref?.();
+                void prepared.promise.then(resolve, reject);
+            }).finally(() => {
+                if (timer)
+                    clearTimeout(timer);
+            });
+        });
+        // The bounded result, not the potentially immortal persistence promise,
+        // gates the next record. `operation` remains observed by `bounded`, so a
+        // late rejection cannot become an unhandled promise rejection.
+        const tail = bounded.catch(() => undefined);
+        this.tails.set(sessionId, tail);
         const cleanup = () => {
-            if (this.tails.get(sessionId) === next)
+            if (this.tails.get(sessionId) === tail)
                 this.tails.delete(sessionId);
         };
-        void next.then(cleanup, cleanup);
-        return next;
+        void tail.then(cleanup, cleanup);
+        return bounded;
     }
 }
 /**
@@ -64,22 +118,77 @@ export function createSessionRuntimeServices(input) {
     });
     const sessionBus = new InMemorySessionBus();
     const sessionRuntimeIndex = new SessionRuntimeIndex();
-    const sessionMirrorQueue = new SessionMirrorQueue((sessionId, event) => persistSessionEvent(sessionId, event, { sessionLog: input.sessionLog, sessionBus }));
+    const sessionMirrorQueue = new SessionMirrorQueue((sessionId, event) => {
+        // Claim the exact pending projection synchronously when this record reaches
+        // the head of its Session lane. Its id remains stable even if persistence
+        // later times out or fails after the result becomes ambiguous.
+        const pendingResolved = resolvePendingInputEvent(sessionId, event, input.pendingInputs);
+        const pendingId = pendingResolved.pendingId;
+        const promise = (async () => {
+            const finalized = await finalizeGeneratedImageEvent(sessionId, pendingResolved.event, input);
+            try {
+                await persistSessionEvent(sessionId, finalized, {
+                    sessionLog: input.sessionLog,
+                    sessionBus,
+                    strictPersistence: true,
+                    ...(pendingId
+                        ? {
+                            onInputPersisted: async (persistedEvent) => {
+                                if (persistedEvent.clearedPendingId !== pendingId)
+                                    return;
+                                input.pendingInputs?.resolve(sessionId, pendingId);
+                                if (!input.onPendingInputPersisted || !pendingResolved.clientMessageId)
+                                    return;
+                                await input.onPendingInputPersisted({
+                                    sessionId,
+                                    pendingId: persistedEvent.clearedPendingId,
+                                    clientMessageId: pendingResolved.clientMessageId,
+                                    responseId: persistedEvent.item.responseId,
+                                    messageItemId: persistedEvent.item.id,
+                                });
+                            },
+                        }
+                        : {}),
+                });
+            }
+            catch (error) {
+                if (pendingId) {
+                    throw new PendingInputMirrorPersistenceError(error, pendingId);
+                }
+                throw error;
+            }
+            sessionRuntimeIndex.observe(sessionId, finalized);
+        })();
+        return {
+            promise,
+            ...(pendingId
+                ? {
+                    abandonToken: pendingId,
+                    onAmbiguous: () => input.pendingInputs?.resolve(sessionId, pendingId),
+                }
+                : {}),
+        };
+    }, input.mirrorStallTimeoutMs);
     const mirrorSessionEvent = (sessionId, event) => {
-        sessionRuntimeIndex.observe(sessionId, event);
         return sessionMirrorQueue.enqueue(sessionId, event);
     };
     const conversationRuntime = new ConversationRuntime({
         config: input.config,
         executor: runnerManager,
         sessionBus,
-        sessionEventSink: mirrorSessionEvent,
     });
     runnerManager.onMirror((sessionId, event) => {
-        void mirrorSessionEvent(sessionId, event).catch((error) => {
+        return mirrorSessionEvent(sessionId, event).catch((error) => {
             input.onMirrorError?.(error, sessionId);
+            throw error;
         });
     });
+    runnerManager.onMirrorAbandon((sessionId, pendingId) => {
+        input.pendingInputs?.resolve(sessionId, pendingId);
+    });
+    runnerManager.onMirrorSupersede((sessionId) => {
+        input.pendingInputs?.deleteSession(sessionId);
+    });
     return {
         sessionStore,
         runnerManager,
@@ -89,6 +198,137 @@ export function createSessionRuntimeServices(input) {
         publishSessionEvent: mirrorSessionEvent,
     };
 }
+class PendingInputMirrorPersistenceError extends Error {
+    abandonToken;
+    statusCode;
+    constructor(error, abandonToken) {
+        super(error instanceof Error ? error.message : String(error), { cause: error });
+        this.abandonToken = abandonToken;
+        this.name = "PendingInputMirrorPersistenceError";
+        if (typeof error === "object" &&
+            error !== null &&
+            typeof error.statusCode === "number") {
+            this.statusCode = error.statusCode;
+        }
+    }
+}
+/** Drain the oldest pending web input when the Provider transcript produces a
+ * real user record. The transcript is the only durable writer; the returned id
+ * lets clients replace the exact temporary bubble. */
+function resolvePendingInputEvent(sessionId, event, pendingInputs) {
+    if (event.type !== "session.input.consumed" ||
+        event.item.type !== "message" ||
+        event.item.data.role !== "user" ||
+        event.item.data.isMeta ||
+        event.item.parentToolCallId !== undefined) {
+        return { event };
+    }
+    const pending = pendingInputs?.peekOldest(sessionId);
+    if (!pending)
+        return { event };
+    const fileParts = pending.content.filter((part) => part.type === "input_image" || part.type === "input_file");
+    const alreadyHasFiles = event.item.data.content.some((part) => part.type === "input_image" || part.type === "input_file");
+    const containsInternalResourceMarker = event.item.data.content.some((part) => part.type === "input_text" &&
+        /\[\[RYNX_(?:IMAGE|FILE)_RESOURCE\s/.test(part.text));
+    const content = containsInternalResourceMarker
+        ? pending.content
+        : fileParts.length > 0 && !alreadyHasFiles
+            ? [...fileParts, ...event.item.data.content]
+            : event.item.data.content;
+    return {
+        pendingId: pending.pendingId,
+        clientMessageId: pending.clientMessageId,
+        event: {
+            ...event,
+            clearedPendingId: pending.pendingId,
+            ...(content !== event.item.data.content
+                ? {
+                    item: {
+                        ...event.item,
+                        data: {
+                            ...event.item.data,
+                            content,
+                        },
+                    },
+                }
+                : {}),
+        },
+    };
+}
+async function finalizeGeneratedImageEvent(sessionId, event, input) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return event;
+    }
+    const rawData = event.item.data;
+    const pending = rawData.__rynxGeneratedImage;
+    if (!pending)
+        return event;
+    const { __rynxGeneratedImage: _omitted, ...data } = rawData;
+    try {
+        const pathMediaType = pending.savedPath && isAbsolute(pending.savedPath)
+            ? imageMediaTypeFromPath(pending.savedPath)
+            : undefined;
+        const generatedImage = pathMediaType && pending.savedPath
+            ? {
+                path: pending.savedPath,
+                filename: basename(pending.savedPath),
+                mediaType: pathMediaType,
+            }
+            : pending.result && input.materializeGeneratedImage
+                ? await input.materializeGeneratedImage({
+                    sessionId,
+                    sourceId: event.item.id,
+                    result: pending.result,
+                })
+                : undefined;
+        return {
+            ...event,
+            item: {
+                ...event.item,
+                data: {
+                    ...data,
+                    ...(generatedImage ? { generatedImage } : {}),
+                    ...(!generatedImage && pending.savedPath && !isAbsolute(pending.savedPath)
+                        ? { output: `${data.output}\nImage path was not absolute; preview omitted.`.trim() }
+                        : {}),
+                },
+            },
+        };
+    }
+    catch (error) {
+        input.onMirrorError?.(error, sessionId);
+        // The source bytes are part of an ordinary durable delivery.
+        // Only deterministic validation/conflict failures may discard their
+        // preview; infrastructure and explicitly retryable resource failures must
+        // NACK so the child retries the exact image commit.
+        if (!(error instanceof MachineSessionServiceFailure) ||
+            error.retryable) {
+            throw error;
+        }
+        return {
+            ...event,
+            item: {
+                ...event.item,
+                data: {
+                    ...data,
+                    output: `${data.output}\nImage preview unavailable.`.trim(),
+                },
+            },
+        };
+    }
+}
+function imageMediaTypeFromPath(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".png": return "image/png";
+        case ".jpg":
+        case ".jpeg": return "image/jpeg";
+        case ".webp": return "image/webp";
+        case ".gif": return "image/gif";
+        case ".svg": return "image/svg+xml";
+        default: return undefined;
+    }
+}
 /**
  * The HTTP surface is just a liveness probe for container orchestration — all
  * agent capabilities are forwarded through the mounted channel plugins (the
@@ -137,7 +377,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)
@@ -160,14 +400,58 @@ 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");
+        if (!localMachineSessions) {
+            throw new Error("plugin runtime requires the machine Session service");
+        }
         pluginRuntime.bindHostServices({
-            conversationRuntime,
             capabilities: runnerManager,
             sessionStore,
             sessionRegistry,
+            sessionRuns: localMachineSessions,
+            sessionFiles: localMachineSessions,
             agentCatalog: {
                 list: async () => (await listAgentSpecs()).map(toPluginAgentSummary),
                 get: async (id) => {
@@ -180,9 +464,57 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                     session: input.session,
                 }),
             },
+            sessionActivity: (sessionId) => {
+                const snapshot = sessionRuntimeIndex.snapshot(sessionId);
+                return {
+                    ...snapshot,
+                    status: snapshot.pendingInteractions.length > 0
+                        ? "waiting"
+                        : snapshot.status,
+                };
+            },
             interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
             terminateSession: (sessionId) => runnerManager.terminateLiveSession(sessionId),
+            ...(sessionLog
+                ? {
+                    sessionTimeline: {
+                        hasItem: async (sessionId, itemId) => Boolean(await sessionLog.get(sessionId, itemId)),
+                        projectText: async ({ sessionId, responseId, itemId, text }) => {
+                            const event = {
+                                type: "response.output_item.done",
+                                responseId,
+                                item: {
+                                    id: itemId,
+                                    sessionId,
+                                    position: -1,
+                                    responseId,
+                                    status: "completed",
+                                    createdAt: Date.now(),
+                                    createdBy: "plugin_projection",
+                                    type: "message",
+                                    data: { role: "assistant", content: [{ type: "output_text", text }] },
+                                },
+                            };
+                            // Projection is an acknowledged durable operation, unlike the
+                            // provider mirror's deliberately best-effort live fan-out.
+                            // Append first and only then publish; a failed append leaves the
+                            // projection ledger pending so the Plugin can retry safely.
+                            await sessionLog.append(sessionId, [event.item]);
+                            sessionServices.sessionBus.publish(sessionId, event);
+                        },
+                    },
+                }
+                : {}),
             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
@@ -196,40 +528,55 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             sourceSessionId: r.from,
             targetSessionId: r.to,
             kind: r.kind,
+        }).catch((error) => {
+            if (error instanceof MachineSessionServiceInputError) {
+                throw Object.assign(error, { statusCode: 400 });
+            }
+            if (error instanceof MachineSessionServiceFailure) {
+                // A mismatched pre-existing target is a deterministic payload conflict,
+                // not an HTTP-style concurrent 409. Surface it as permanent so the
+                // three-attempt permanent-error budget can stop the rotation lane.
+                const statusCode = error.code === "outcome_unknown"
+                    ? 503
+                    : error.code === "not_found"
+                        ? 404
+                        : 422;
+                throw Object.assign(error, { statusCode });
+            }
+            throw error;
         });
     });
-    const controlShutdown = new AbortController();
+    if (localMachineSessions) {
+        runnerManager.onCollaborationMode((sessionId, mode) => {
+            localMachineSessions.recordNativeCollaborationMode(sessionId, mode);
+        });
+    }
     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",
@@ -238,15 +585,6 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 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,
@@ -265,19 +603,48 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             if (control?.emulator) {
                 webSocketServers.push(attachEmulatorTouchWs(server, { emulator: control.emulator }));
             }
+            startupWebSocketServers = webSocketServers;
+            // Plugin recovery fences and revokes any product-owned Portal authority.
+            // Do not expose the listener until every enabled Plugin got its serialized
+            // startup attempt; startPluginRuntimes absorbs individual failures.
+            await (pluginRuntime?.startPluginRuntimes() ?? Promise.resolve());
+            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,
+                });
+            }
             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?.()),
                     () => pluginRuntime?.dispose() ?? Promise.resolve(),
                     () => 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;