@agimon-ai/po-core 0.0.0-alpha.0

package/dist/headlessHub.mjs

@@ -0,0 +1,1005 @@
+import "./src/schemas/notification.mjs";
+import "./src/server/directHarnessRuntime.mjs";
+import { createDoomPluginRegistry } from "./src/schemas/pluginProtocol.mjs";
+import "./pluginProtocol.mjs";
+import { PROFILE_ICON_MIME_TYPES } from "./src/schemas/profileIdentity.mjs";
+import { createDoomServerHost } from "./src/services/serverFacet/index.mjs";
+import { installServerFacets } from "./src/server/serverFacetLoader.mjs";
+import "./serverFacet.mjs";
+import { readSessionGitStatus } from "./src/services/sessionGitStatus/index.mjs";
+import crypto from "node:crypto";
+//#region src/server/headlessHub.ts
+const AUTHORIZATION_HEADER = "authorization";
+const CHANNEL_PRIORITY = {
+	global: 0,
+	workspace: 1,
+	session: 2
+};
+const ICON_VERSION_LENGTH = 12;
+const ICON_DATA_URL = /^data:([a-z/+.-]+);base64,([A-Za-z0-9+/=]+)$/u;
+/** A rail line, not a log: a longer label is cut to this. */
+const MAX_ACTIVITY_LABEL = 80;
+/**
+* When a reopened session last settled, from the marker its runtime journals at every run end.
+* Without it a session with a whole history would read as fresh until its next turn.
+*/
+async function lastSettledAt(host) {
+	try {
+		const entry = (await host.runtime.readEntries()).entries.findLast((entry) => entry.type === "custom" && entry.customType === "po.agent-settled");
+		const data = entry?.type === "custom" ? entry.data : void 0;
+		return typeof data?.timestamp === "number" && Number.isFinite(data.timestamp) ? new Date(data.timestamp).toISOString() : void 0;
+	} catch {
+		return;
+	}
+}
+function scopeOf(session) {
+	return {
+		sessionId: session.id,
+		...session.workspaceId === void 0 ? {} : { workspaceId: session.workspaceId },
+		cwd: session.cwd,
+		...session.environment === void 0 ? {} : { environment: session.environment },
+		...session.host.sessionContext === void 0 ? {} : { sessionContext: session.host.sessionContext }
+	};
+}
+/** Owns direct, same-process session and channel state for presentation adapters. */
+function createHeadlessHub(options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const pendingSetups = /* @__PURE__ */ new Map();
+	const activities = /* @__PURE__ */ new Map();
+	const present = (session) => {
+		const pending = pendingSetups.get(session.id);
+		const activity = activities.get(session.id);
+		if (pending === void 0 && activity === void 0) return session;
+		return {
+			...session,
+			...pending === void 0 ? {} : { pendingSetups: pending },
+			...activity === void 0 ? {} : { activity }
+		};
+	};
+	const pluginRegistry = createDoomPluginRegistry();
+	const channels = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	const subscriptions = /* @__PURE__ */ new Set();
+	const sessionCleanups = /* @__PURE__ */ new Map();
+	const presentationCleanups = /* @__PURE__ */ new Map();
+	/** Profile icons by session, kept out of summaries because each can be hundreds of kilobytes. */
+	const avatarIcons = /* @__PURE__ */ new Map();
+	const sessionShutdowns = /* @__PURE__ */ new Map();
+	const directEventListeners = /* @__PURE__ */ new Map();
+	const directEventLatest = /* @__PURE__ */ new Map();
+	const maxDirectEventLatest = 4096;
+	const communicationEndpoints = /* @__PURE__ */ new Map();
+	let closed = false;
+	const mounts = /* @__PURE__ */ new Map();
+	const disposeMount = async (mounted) => {
+		try {
+			await mounted.installed.dispose();
+		} finally {
+			mounted.host.dispose();
+		}
+	};
+	const workspaces = /* @__PURE__ */ new Map();
+	const worktreeProvisioners = /* @__PURE__ */ new Map();
+	let sessionService;
+	const mountKey = (mount) => mount.scope === "global" ? "global" : mount.scope === "workspace" ? `workspace:${mount.workspaceId}` : `session:${mount.sessionId}`;
+	const belongs = (mount, session) => mount.scope === "global" || (mount.scope === "workspace" ? session.workspaceId === mount.workspaceId : session.id === mount.sessionId);
+	const canClose = (mount, session) => belongs(mount, session) || mount.scope === "session" && session.parentSessionId === mount.sessionId;
+	const canCommunicate = (sourceId, targetId) => {
+		if (closed || sourceId === targetId) return false;
+		const source = sessions.get(sourceId);
+		const target = sessions.get(targetId);
+		return source !== void 0 && target !== void 0 && (source.parentSessionId === target.id || target.parentSessionId === source.id);
+	};
+	const registerReservedWorktreeProvisioner = (mount, provisioner) => {
+		const key = mountKey(mount);
+		if (worktreeProvisioners.has(key)) throw new Error("A worktree provisioner is already registered.");
+		worktreeProvisioners.set(key, {
+			mount,
+			provisioner
+		});
+		return () => {
+			if (worktreeProvisioners.get(key)?.provisioner === provisioner) worktreeProvisioners.delete(key);
+		};
+	};
+	const worktreeProvisionerFor = (parent) => {
+		let provisioner;
+		let priority = -1;
+		for (const { mount, provisioner: candidate } of worktreeProvisioners.values()) {
+			if (!belongs(mount, parent) || CHANNEL_PRIORITY[mount.scope] <= priority) continue;
+			provisioner = candidate;
+			priority = CHANNEL_PRIORITY[mount.scope];
+		}
+		return provisioner;
+	};
+	const selectedChannels = (session) => {
+		const selected = /* @__PURE__ */ new Map();
+		for (const started of channels.values()) {
+			if (!belongs(started.mount, session)) continue;
+			const previous = selected.get(started.channel.frameType);
+			if (!previous || CHANNEL_PRIORITY[started.mount.scope] > CHANNEL_PRIORITY[previous.mount.scope]) selected.set(started.channel.frameType, started);
+		}
+		return [...selected.values()];
+	};
+	const selectedChannel = (session, frameType) => selectedChannels(session).find((started) => started.channel.frameType === frameType);
+	/**
+	* One channel serves a session: the narrowest mount that reaches it. A package that
+	* registers the same channel globally and per workspace would otherwise run two
+	* sources against one session, and only the narrower one can publish or receive.
+	*
+	* Compared by mount scope rather than identity so a channel being started already
+	* knows which sessions it is taking over.
+	*/
+	const serves = (mount, frameType, session) => {
+		if (!belongs(mount, session)) return false;
+		const current = selectedChannel(session, frameType);
+		return current === void 0 || CHANNEL_PRIORITY[mount.scope] >= CHANNEL_PRIORITY[current.mount.scope];
+	};
+	const directEventKey = (frameType, sessionId) => `${frameType}\0${sessionId}`;
+	const directEvents = {
+		publish(frameType, sessionId, payload) {
+			if (closed) return;
+			const key = directEventKey(frameType, sessionId);
+			directEventLatest.set(key, payload);
+			while (directEventLatest.size > maxDirectEventLatest) {
+				const oldest = directEventLatest.keys().next().value;
+				if (oldest === void 0) break;
+				directEventLatest.delete(oldest);
+			}
+			const listeners = directEventListeners.get(key);
+			if (listeners === void 0) return;
+			for (const listener of listeners) listener(payload);
+		},
+		subscribe(frameType, sessionId, listener, options) {
+			if (closed) return () => void 0;
+			const key = directEventKey(frameType, sessionId);
+			const listeners = directEventListeners.get(key) ?? /* @__PURE__ */ new Set();
+			listeners.add(listener);
+			directEventListeners.set(key, listeners);
+			if (options?.replayLatest && directEventLatest.has(key)) listener(directEventLatest.get(key));
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				listeners.delete(listener);
+				if (listeners.size === 0) directEventListeners.delete(key);
+			};
+		},
+		clearSession(sessionId) {
+			const suffix = `\0${sessionId}`;
+			for (const key of directEventLatest.keys()) if (key.endsWith(suffix)) directEventLatest.delete(key);
+		},
+		close() {
+			directEventListeners.clear();
+			directEventLatest.clear();
+		}
+	};
+	const announceCommunicationReady = (sessionId) => {
+		const current = communicationEndpoints.get(sessionId);
+		if (current?.ready !== true) return;
+		for (const [peerSessionId, peer] of communicationEndpoints) {
+			if (!peer.ready || !canCommunicate(sessionId, peerSessionId)) continue;
+			for (const listener of current.readyListeners) listener(peerSessionId);
+			for (const listener of peer.readyListeners) listener(sessionId);
+		}
+	};
+	const bindCommunication = (sessionId) => {
+		const existing = communicationEndpoints.get(sessionId);
+		if (existing !== void 0) return existing.endpoint;
+		const listeners = /* @__PURE__ */ new Map();
+		const readyListeners = /* @__PURE__ */ new Set();
+		let endpoint;
+		const record = {
+			listeners,
+			readyListeners,
+			ready: false,
+			get endpoint() {
+				return endpoint;
+			}
+		};
+		endpoint = {
+			sessionId,
+			publish(targetSessionId, type, payload) {
+				if (!canCommunicate(sessionId, targetSessionId)) return false;
+				const target = communicationEndpoints.get(targetSessionId);
+				if (target?.ready !== true) return false;
+				for (const listener of target.listeners.get(type) ?? []) listener(sessionId, payload);
+				return true;
+			},
+			subscribe(type, listener) {
+				const current = listeners.get(type) ?? /* @__PURE__ */ new Set();
+				current.add(listener);
+				listeners.set(type, current);
+				return () => {
+					current.delete(listener);
+					if (current.size === 0) listeners.delete(type);
+				};
+			},
+			onPeerReady(listener) {
+				readyListeners.add(listener);
+				if (!record.ready) {
+					record.ready = true;
+					announceCommunicationReady(sessionId);
+				} else for (const [peerSessionId, peer] of communicationEndpoints) if (peer.ready && canCommunicate(sessionId, peerSessionId)) listener(peerSessionId);
+				return () => readyListeners.delete(listener);
+			},
+			close() {
+				if (communicationEndpoints.get(sessionId)?.endpoint !== endpoint) return;
+				communicationEndpoints.delete(sessionId);
+				listeners.clear();
+				readyListeners.clear();
+			}
+		};
+		communicationEndpoints.set(sessionId, record);
+		return endpoint;
+	};
+	const queuedEvents = [];
+	let publishing = false;
+	const emit = (event) => {
+		if (closed) return;
+		queuedEvents.push(event.kind === "upsert" ? {
+			...event,
+			session: present(event.session)
+		} : event);
+		if (publishing) return;
+		publishing = true;
+		try {
+			for (let index = 0; index < queuedEvents.length; index += 1) for (const listener of listeners) listener(queuedEvents[index]);
+		} finally {
+			queuedEvents.length = 0;
+			publishing = false;
+		}
+	};
+	const sessionScopes = () => [...sessions.values()].map(scopeOf);
+	const publish = (frameType, sessionId, payload, connectionId) => {
+		if (!sessions.has(sessionId)) return;
+		emit({
+			kind: "channel",
+			frameType,
+			sessionId,
+			payload,
+			...connectionId === void 0 ? {} : { connectionId }
+		});
+	};
+	/**
+	* Hub-owned calls carry the hub credential, so a session API can tell them from a
+	* browser call it must not trust. Browser traffic reaches a session API through
+	* requestApi instead, and keeps the headers its caller sent.
+	*/
+	const hubAuthenticated = (request) => {
+		const token = options.hubToken?.();
+		if (token === void 0 || token === "") return request;
+		const headers = new Headers(request.headers);
+		if (headers.has(AUTHORIZATION_HEADER)) return request;
+		headers.set(AUTHORIZATION_HEADER, `Bearer ${token}`);
+		return {
+			...request,
+			headers
+		};
+	};
+	const reservationsFor = (mount) => {
+		const reservations = options.sessionReservations;
+		if (!reservations) return void 0;
+		const check = (parentId) => {
+			const parent = sessions.get(parentId);
+			if (!parent || !belongs(mount, parent)) throw new Error("Parent session is outside this mount.");
+		};
+		return {
+			read: (id, parentId) => {
+				check(parentId);
+				return reservations.read(id, parentId);
+			},
+			prepare: (id, parentId, cwd) => {
+				check(parentId);
+				return reservations.prepare(id, parentId, cwd);
+			},
+			complete: (id, parentId) => {
+				check(parentId);
+				return reservations.complete(id, parentId);
+			}
+		};
+	};
+	const channelHost = (frameType, mount) => ({
+		sessions: () => sessionScopes().filter((scope) => {
+			const session = sessions.get(scope.sessionId);
+			return session !== void 0 && serves(mount, frameType, session);
+		}),
+		sessionService: {
+			reservations: reservationsFor(mount),
+			create: async (request) => {
+				if (mount.scope === "workspace" && request.parentSessionId === void 0) {
+					if (request.reservationId !== void 0) throw new Error("A reserved session requires its owning parent.");
+					if (options.createSession === void 0) throw new Error("The cockpit session service cannot create sessions in this host.");
+					return options.createSession(request, { workspaceId: mount.workspaceId });
+				}
+				if (mount.scope !== "global") {
+					const parent = request.parentSessionId === void 0 ? void 0 : sessions.get(request.parentSessionId);
+					if (!parent || !belongs(mount, parent)) throw new Error("Parent session is outside this mount.");
+				}
+				return sessionService.create(request);
+			},
+			close: async (id) => {
+				const session = sessions.get(id);
+				if (session === void 0) {
+					const shutdown = sessionShutdowns.get(id);
+					if (shutdown !== void 0) {
+						if (!canClose(mount, shutdown.session)) throw new Error("Session is outside this mount.");
+						await shutdown.promise;
+					}
+					return;
+				}
+				if (!canClose(mount, session)) throw new Error("Session is outside this mount.");
+				await sessionService.close(id);
+			},
+			isLive: (id) => sessionService.isLive(id),
+			registerReservedWorktreeProvisioner: (provisioner) => registerReservedWorktreeProvisioner(mount, provisioner),
+			canCommunicate: (sourceId, targetId) => {
+				const source = sessions.get(sourceId);
+				return source !== void 0 && belongs(mount, source) && sessionService.canCommunicate?.(sourceId, targetId) === true;
+			}
+		},
+		directEvents: {
+			publish: (type, id, payload) => {
+				const session = sessions.get(id);
+				if (session && serves(mount, frameType, session)) directEvents.publish(type, id, payload);
+			},
+			subscribe: (type, id, listener, subscriptionOptions) => {
+				const session = sessions.get(id);
+				return session && serves(mount, frameType, session) ? directEvents.subscribe(type, id, listener, subscriptionOptions) : () => void 0;
+			},
+			close: () => void 0
+		},
+		publish: (sessionId, payload) => {
+			const session = sessions.get(sessionId);
+			if (session && serves(mount, frameType, session)) publish(frameType, sessionId, payload);
+		},
+		publishToConnection: (connectionId, sessionId, payload) => {
+			const session = sessions.get(sessionId);
+			if (connectionId === "" || !session || !serves(mount, frameType, session)) return false;
+			publish(frameType, sessionId, payload, connectionId);
+			return true;
+		},
+		requestSessionApi: async (scope, request) => {
+			const session = sessions.get(scope.sessionId);
+			if (!session || !belongs(mount, session)) return Response.json({ error: "Session not found." }, { status: 404 });
+			if (options.requestSessionApi === void 0) return Response.json({ error: "Session API unavailable." }, { status: 404 });
+			return options.requestSessionApi(scope, hubAuthenticated(request));
+		},
+		...options.computerUse === void 0 ? {} : { computerUse: {
+			get available() {
+				return options.computerUse.available;
+			},
+			request(scope, request) {
+				const session = sessions.get(scope.sessionId);
+				if (!session || !belongs(mount, session)) throw new Error("Computer-use session is outside this mount.");
+				return options.computerUse.request(scopeOf(session), request);
+			}
+		} },
+		onNotice: (message) => options.onNotice?.(message)
+	});
+	const startChannel = (channel, mount) => {
+		const key = `${mountKey(mount)}:${channel.frameType}`;
+		if (channels.has(key)) {
+			options.onNotice?.(`hub channel '${channel.frameType}' is already registered`);
+			return;
+		}
+		try {
+			const displaced = /* @__PURE__ */ new Map();
+			for (const session of sessions.values()) {
+				if (!belongs(mount, session)) continue;
+				const previous = selectedChannel(session, channel.frameType);
+				if (previous !== void 0) displaced.set(session.id, previous);
+			}
+			const source = channel.start(channelHost(channel.frameType, mount));
+			const started = {
+				channel,
+				source,
+				mount
+			};
+			channels.set(key, started);
+			for (const session of sessions.values()) {
+				if (selectedChannel(session, channel.frameType) !== started) continue;
+				displaced.get(session.id)?.source.sessionRemoved?.(session.id);
+				source.sessionAdded?.(scopeOf(session));
+			}
+			return started;
+		} catch (error) {
+			options.onNotice?.(`hub channel '${channel.frameType}' failed (${String(error)})`);
+			return;
+		}
+	};
+	const releaseChannel = (channel, started) => {
+		const key = `${mountKey(started.mount)}:${channel.frameType}`;
+		if (channels.get(key) !== started) return;
+		const served = [...sessions.values()].filter((session) => selectedChannel(session, channel.frameType) === started);
+		channels.delete(key);
+		started.source.close();
+		for (const session of served) selectedChannel(session, channel.frameType)?.source.sessionAdded?.(scopeOf(session));
+	};
+	const receiveMountedChannel = (mount, sessionId, frameType, payload, connectionId) => {
+		if (!connectionId) return false;
+		const session = sessions.get(sessionId);
+		if (!session || !belongs(mount, session)) return false;
+		const started = channels.get(`${mountKey(mount)}:${frameType}`);
+		if (!started?.channel.receive) return false;
+		started.channel.receive(scopeOf(session), payload, { connectionId });
+		return true;
+	};
+	const unregisterSession = (sessionId, closeOptions) => {
+		const current = sessions.get(sessionId);
+		if (current === void 0) return;
+		const cleanup = sessionCleanups.get(sessionId);
+		if (cleanup !== void 0) subscriptions.delete(cleanup);
+		communicationEndpoints.get(sessionId)?.endpoint.close();
+		try {
+			for (const { source } of selectedChannels(current)) source.sessionRemoved?.(sessionId);
+			options.computerUse?.forgetSession?.(sessionId);
+		} finally {
+			sessions.delete(sessionId);
+			activities.delete(sessionId);
+			sessionCleanups.delete(sessionId);
+			presentationCleanups.get(sessionId)?.();
+			presentationCleanups.delete(sessionId);
+			avatarIcons.delete(sessionId);
+			directEvents.clearSession?.(sessionId);
+		}
+		emit({
+			kind: "removed",
+			sessionId,
+			...closeOptions?.keepDormant === true ? { dormant: true } : {}
+		});
+	};
+	const startSessionShutdown = (session, closeOptions) => {
+		const existing = sessionShutdowns.get(session.id);
+		if (existing !== void 0) return existing.promise;
+		const shutdown = {
+			session,
+			promise: Promise.resolve(),
+			pending: true
+		};
+		const promise = Promise.resolve().then(() => closeOptions === void 0 ? options.manager.closeSession(session.id) : options.manager.closeSession(session.id, closeOptions));
+		shutdown.promise = promise;
+		sessionShutdowns.set(session.id, shutdown);
+		promise.then(() => {
+			shutdown.pending = false;
+			if (sessionShutdowns.get(session.id) === shutdown) sessionShutdowns.delete(session.id);
+		}, () => {
+			shutdown.pending = false;
+		});
+		return promise;
+	};
+	const register = (session) => {
+		if (closed) throw new Error("The headless hub is closed.");
+		if (sessions.has(session.id)) throw new Error(`Session '${session.id}' is already registered.`);
+		if (sessionShutdowns.get(session.id)?.pending) throw new Error(`Session '${session.id}' is still shutting down.`);
+		sessionShutdowns.delete(session.id);
+		let current = {
+			...session,
+			updatedAt: session.updatedAt ?? session.createdAt,
+			phase: session.phase ?? "idle",
+			phaseSince: session.phaseSince ?? session.createdAt,
+			pendingMessageCount: session.pendingMessageCount ?? 0,
+			everPrompted: session.everPrompted ?? false,
+			awaitingInput: session.awaitingInput ?? false
+		};
+		sessions.set(session.id, current);
+		announceCommunicationReady(session.id);
+		const refreshGit = () => {
+			(options.readGitStatus ?? readSessionGitStatus)(session.cwd).then((git) => {
+				if (closed || sessions.get(session.id)?.host !== session.host) return;
+				if (git?.branch === current.git?.branch && git?.dirty === current.git?.dirty) return;
+				const { git: _previous, ...rest } = current;
+				current = git === void 0 ? rest : {
+					...rest,
+					git
+				};
+				sessions.set(session.id, current);
+				emit({
+					kind: "upsert",
+					session: current
+				});
+			}, (error) => options.onNotice?.(`session ${session.id} git status failed (${error instanceof Error ? error.message : String(error)})`));
+		};
+		const stopPresentation = session.host.onPresentationFrame((frame) => {
+			if (sessions.get(session.id)?.host !== session.host) return;
+			const type = typeof frame.type === "string" ? frame.type : "";
+			const entry = frame.entry;
+			if (type === "entry_appended" && entry?.customType === "doom-notification") {
+				emit({
+					kind: "frame",
+					sessionId: session.id,
+					frame
+				});
+				return;
+			}
+			if (type !== "agent_start" && type !== "agent_settled" && type !== "message_end" && type !== "session_info_changed" && type !== "extension_ui_request" && type !== "extension_ui_answered") return;
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const phase = type === "agent_start" ? "turn" : type === "agent_settled" ? "idle" : current.phase;
+			const phaseChanged = phase !== current.phase;
+			const method = typeof frame.method === "string" ? frame.method : "";
+			const dialog = type === "extension_ui_request" && [
+				"select",
+				"confirm",
+				"input",
+				"editor"
+			].includes(method);
+			const awaitingInput = dialog ? true : type === "extension_ui_answered" || type === "agent_settled" ? false : current.awaitingInput;
+			current = {
+				...current,
+				name: type === "session_info_changed" && typeof frame.name === "string" ? frame.name : current.name,
+				updatedAt: now,
+				phase,
+				phaseSince: phaseChanged ? now : current.phaseSince,
+				everPrompted: current.everPrompted || type === "agent_start",
+				awaitingInput,
+				...type === "agent_settled" ? { lastSettledAt: now } : {}
+			};
+			sessions.set(session.id, current);
+			emit({
+				kind: "upsert",
+				session: current
+			});
+			if (dialog) {
+				const text = (key) => typeof frame[key] === "string" ? { [key]: frame[key] } : {};
+				emit({
+					kind: "frame",
+					sessionId: session.id,
+					frame: {
+						type,
+						...text("id"),
+						method,
+						...text("title"),
+						...text("message")
+					}
+				});
+			}
+			if (type === "agent_settled") refreshGit();
+		});
+		let registered = false;
+		const applyProfile = (profileName) => {
+			if (closed || sessions.get(session.id)?.host !== session.host) return;
+			let identity;
+			if (profileName) {
+				const root = session.workspaceId && workspaces.get(session.workspaceId)?.root || session.cwd;
+				try {
+					identity = options.resolveProfileIdentity?.(root, profileName);
+				} catch (error) {
+					options.onNotice?.(`session ${session.id} profile "${profileName}" could not be resolved (${error instanceof Error ? error.message : String(error)})`);
+				}
+			}
+			const icon = identity?.icon;
+			if (icon) avatarIcons.set(session.id, icon);
+			else avatarIcons.delete(session.id);
+			const profile = profileName ? {
+				name: profileName,
+				...identity?.displayName ? { displayName: identity.displayName } : {},
+				...icon ? { iconVersion: crypto.createHash("sha256").update(icon).digest("hex").slice(0, ICON_VERSION_LENGTH) } : {}
+			} : void 0;
+			const previous = current.profile;
+			if (previous?.name === profile?.name && previous?.displayName === profile?.displayName && previous?.iconVersion === profile?.iconVersion) return;
+			const { profile: _previous, ...rest } = current;
+			current = profile === void 0 ? rest : {
+				...rest,
+				profile
+			};
+			sessions.set(session.id, current);
+			if (registered) emit({
+				kind: "upsert",
+				session: current
+			});
+		};
+		const stopSelection = session.host.onSelection?.((selection) => applyProfile(selection.profile));
+		presentationCleanups.set(session.id, () => {
+			stopPresentation();
+			stopSelection?.();
+		});
+		for (const { source } of selectedChannels(current)) source.sessionAdded?.(scopeOf(session));
+		const active = () => sessions.get(session.id)?.host === session.host && !closed;
+		const cleanup = () => {
+			subscriptions.delete(cleanup);
+			sessionCleanups.delete(session.id);
+			if (!active()) return;
+			closeSession(session.id).catch((error) => options.onNotice?.(`session ${session.id} cleanup failed (${error instanceof Error ? error.message : String(error)})`));
+		};
+		sessionCleanups.set(session.id, cleanup);
+		session.host.runtime.exited.then(cleanup, cleanup);
+		subscriptions.add(cleanup);
+		registered = true;
+		emit({
+			kind: "upsert",
+			session: current
+		});
+		refreshGit();
+	};
+	const closeSession = async (sessionId, closeOptions) => {
+		const pending = sessionShutdowns.get(sessionId);
+		if (pending !== void 0) {
+			await pending.promise;
+			return;
+		}
+		const session = sessions.get(sessionId);
+		if (session === void 0) return;
+		unregisterSession(sessionId, closeOptions);
+		await startSessionShutdown(session, closeOptions);
+	};
+	const promptTarget = (sessionId, parentSessionId) => {
+		const session = closed ? void 0 : sessions.get(sessionId);
+		if (session === void 0) throw new Error("The session is not live.");
+		if (parentSessionId !== void 0 && session.parentSessionId !== parentSessionId) throw new Error("Only the parent session can drive this session.");
+		return session;
+	};
+	sessionService = {
+		create: async (request) => {
+			if (options.createSession === void 0) throw new Error("The cockpit session service cannot create sessions in this host.");
+			return options.createSession(request);
+		},
+		close: closeSession,
+		isLive: (sessionId) => !closed && sessions.has(sessionId),
+		readExecutionState: async (sessionId, readOptions) => {
+			const target = promptTarget(sessionId, readOptions?.parentSessionId);
+			if (!target.host.readExecutionState) throw new Error("The session cannot report execution state.");
+			return target.host.readExecutionState();
+		},
+		prompt: async (sessionId, text, promptOptions) => {
+			promptOptions?.signal?.throwIfAborted();
+			const { settled } = await promptTarget(sessionId, promptOptions?.parentSessionId).host.runtime.submitPrompt(text);
+			return { settled };
+		},
+		abort: async (sessionId, abortOptions) => {
+			await promptTarget(sessionId, abortOptions?.parentSessionId).host.runtime.abort();
+		},
+		steer: async (sessionId, message, steerOptions) => {
+			await promptTarget(sessionId, steerOptions?.parentSessionId).host.runtime.steer(message);
+		},
+		release: async (sessionId, releaseOptions) => {
+			promptTarget(sessionId, releaseOptions?.parentSessionId);
+			await closeSession(sessionId, { keepDormant: true });
+		},
+		reservations: options.sessionReservations,
+		provisionReservedWorktree: async (request) => {
+			const parent = sessions.get(request.parentSessionId);
+			const provisioner = parent === void 0 ? void 0 : worktreeProvisionerFor(parent);
+			if (provisioner === void 0) throw new Error("Automatic conversation worktree provisioning is unavailable.");
+			return provisioner(request);
+		},
+		registerReservedWorktreeProvisioner: (provisioner) => registerReservedWorktreeProvisioner({ scope: "global" }, provisioner),
+		canCommunicate,
+		bindCommunication
+	};
+	const installMount = async (facets, suppliedContext, announceWorkspace) => {
+		if (closed) throw new Error("The headless hub is closed.");
+		const context = suppliedContext ?? {
+			scope: "global",
+			...options.hubToken?.() === void 0 ? {} : { hubToken: options.hubToken() },
+			sessionService,
+			directEvents,
+			onNotice: (message) => options.onNotice?.(message)
+		};
+		if (context.scope === "session") throw new Error("Session facets belong to their session host.");
+		if (context.scope === "workspace" && (!context.workspaceId || !context.workspaceRoot)) throw new Error("Workspace mounts require an admitted identity and root.");
+		const mount = context.scope === "global" ? { scope: "global" } : {
+			scope: "workspace",
+			workspaceId: context.workspaceId
+		};
+		const key = mountKey(mount);
+		if (mounts.has(key)) throw new Error(`The '${key}' facets are already mounted.`);
+		const host = createDoomServerHost({
+			scope: context.scope,
+			context: {
+				...context,
+				sessionService: channelHost("", mount).sessionService,
+				directEvents: channelHost("", mount).directEvents,
+				receiveChannel: (sessionId, frameType, payload, connectionId) => receiveMountedChannel(mount, sessionId, frameType, payload, connectionId)
+			},
+			mountChannel: (channel) => {
+				const started = startChannel(channel, mount);
+				if (started === void 0) return {
+					mounted: false,
+					dispose: () => void 0
+				};
+				return {
+					mounted: true,
+					dispose: () => releaseChannel(channel, started)
+				};
+			},
+			pluginRegistry
+		});
+		try {
+			const installed = await installServerFacets({
+				host,
+				facets,
+				onNotice: options.onNotice
+			});
+			if (closed) {
+				await installed.dispose();
+				throw new Error("The headless hub was closed while mounting facets.");
+			}
+			mounts.set(key, {
+				host,
+				installed,
+				context,
+				facets
+			});
+			if (announceWorkspace && mount.scope === "workspace") {
+				const workspace = {
+					id: mount.workspaceId,
+					root: context.workspaceRoot,
+					available: true
+				};
+				workspaces.set(mount.workspaceId, workspace);
+				emit({
+					kind: "workspace_upsert",
+					workspace
+				});
+			}
+		} catch (error) {
+			host.dispose();
+			throw error;
+		}
+	};
+	const mountFacets = (facets, suppliedContext) => installMount(facets, suppliedContext, true);
+	const replacements = /* @__PURE__ */ new Map();
+	const replaceFacets = (mount, facets) => {
+		if (mount.scope === "session") return Promise.reject(/* @__PURE__ */ new Error("Session facets belong to their session host."));
+		const key = mountKey(mount);
+		const run = (replacements.get(key) ?? Promise.resolve()).then(async () => {
+			if (closed) throw new Error("The headless hub is closed.");
+			const previous = mounts.get(key);
+			if (previous === void 0) throw new Error(`The '${key}' facets are not mounted.`);
+			mounts.delete(key);
+			await disposeMount(previous);
+			if (closed || mount.scope === "workspace" && !workspaces.has(mount.workspaceId)) return;
+			try {
+				await installMount(facets, previous.context, false);
+			} catch (error) {
+				await installMount(previous.facets, previous.context, false).catch((rollbackError) => options.onNotice?.(`The '${key}' facets could not be restored (${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)})`));
+				throw error;
+			}
+		});
+		const settled = run.then(() => void 0, () => void 0);
+		replacements.set(key, settled);
+		settled.then(() => {
+			if (replacements.get(key) === settled) replacements.delete(key);
+		});
+		return run;
+	};
+	return {
+		sessionService,
+		directEvents,
+		...options.computerUse === void 0 ? {} : { computerUse: options.computerUse },
+		snapshot: () => [...sessions.values()].map(present),
+		session: (sessionId) => {
+			const session = sessions.get(sessionId);
+			return session === void 0 ? void 0 : present(session);
+		},
+		setPendingSessionSetups(sessionId, pending) {
+			if (JSON.stringify(pendingSetups.get(sessionId) ?? []) === JSON.stringify(pending)) return;
+			pendingSetups.set(sessionId, Object.freeze([...pending]));
+			const session = sessions.get(sessionId);
+			if (session) emit({
+				kind: "upsert",
+				session: present(session)
+			});
+		},
+		setSessionActivity(sessionId, activity) {
+			const session = sessions.get(sessionId);
+			if (session === void 0) return;
+			const next = activity === void 0 ? void 0 : Object.freeze({
+				label: activity.label.slice(0, MAX_ACTIVITY_LABEL),
+				...activity.attention === true ? { attention: true } : {},
+				...activity.since === void 0 ? {} : { since: activity.since }
+			});
+			if (JSON.stringify(activities.get(sessionId)) === JSON.stringify(next)) return;
+			if (next === void 0) activities.delete(sessionId);
+			else activities.set(sessionId, next);
+			emit({
+				kind: "upsert",
+				session: present(session)
+			});
+		},
+		runtime: (sessionId) => sessions.get(sessionId)?.host.runtime,
+		sessionAvatar(sessionId) {
+			const match = ICON_DATA_URL.exec(avatarIcons.get(sessionId) ?? "");
+			const mimeType = match?.[1];
+			if (match === null || !PROFILE_ICON_MIME_TYPES.includes(mimeType ?? "")) return void 0;
+			return {
+				mimeType,
+				bytes: Buffer.from(match[2], "base64")
+			};
+		},
+		onEvent(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		register,
+		notifySessionRemoved(sessionId) {
+			emit({
+				kind: "removed",
+				sessionId
+			});
+		},
+		mountFacets,
+		replaceFacets,
+		workspaces: () => [...workspaces.values()],
+		registerWorkspace(workspace) {
+			workspaces.set(workspace.id, workspace);
+			emit({
+				kind: "workspace_upsert",
+				workspace
+			});
+		},
+		admitWorkspace: async (request) => {
+			if (!options.admitWorkspace) throw new Error("Workspace admission is unavailable.");
+			return options.admitWorkspace(request);
+		},
+		async removeWorkspace(id) {
+			if ([...sessions.values()].some((session) => session.workspaceId === id)) throw new Error("Workspace still has live sessions.");
+			const key = mountKey({
+				scope: "workspace",
+				workspaceId: id
+			});
+			const mounted = mounts.get(key);
+			if (!workspaces.has(id)) return;
+			options.onWorkspaceRemoved?.(id);
+			workspaces.delete(id);
+			emit({
+				kind: "workspace_removed",
+				workspaceId: id
+			});
+			if (!mounted) return;
+			mounts.delete(key);
+			await disposeMount(mounted);
+		},
+		async requestApi(mount, basePath, request) {
+			if (closed) return Response.json({ error: "Server is closed." }, { status: 503 });
+			if (mount.scope === "session") {
+				const session = sessions.get(mount.sessionId);
+				if (!session || !options.requestSessionApi) return Response.json({ error: "Session not found." }, { status: 404 });
+				const url = new URL(request.url);
+				return options.requestSessionApi(scopeOf(session), {
+					basePath,
+					path: `${url.pathname}${url.search}`,
+					method: request.method,
+					headers: request.headers,
+					signal: request.signal,
+					body: request.body === null ? void 0 : new Uint8Array(await request.arrayBuffer())
+				});
+			}
+			const handler = mounts.get(mountKey(mount))?.host.handlerFor(basePath);
+			if (!handler) return Response.json({ error: `API '${basePath}' is not mounted in ${mountKey(mount)}.` }, { status: 404 });
+			return handler.fetch(request);
+		},
+		pluginRegistry,
+		invokePlugin: (call, direction, caller) => pluginRegistry.invoke(call, direction, caller),
+		async create(sessionOptions) {
+			const id = sessionOptions.sessionId;
+			if (closed) throw new Error("The headless hub is closed.");
+			if (sessions.has(id)) throw new Error(`Session '${id}' is already registered.`);
+			if (sessionShutdowns.get(id)?.pending) throw new Error(`Session '${id}' is still shutting down.`);
+			const host = await options.manager.create(sessionOptions);
+			const settledAt = await lastSettledAt(host);
+			const session = {
+				id: sessionOptions.sessionId,
+				workspaceId: sessionOptions.workspaceId,
+				webComposition: sessionOptions.webComposition,
+				nativeComposition: sessionOptions.nativeComposition,
+				name: sessionOptions.sessionName,
+				cwd: sessionOptions.cwd,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...sessionOptions.parentSessionId === void 0 ? {} : { parentSessionId: sessionOptions.parentSessionId },
+				...sessionOptions.sessionProvenance === void 0 ? {} : { sessionProvenance: sessionOptions.sessionProvenance },
+				environment: sessionOptions.environment,
+				...settledAt === void 0 ? {} : {
+					everPrompted: true,
+					lastSettledAt: settledAt
+				},
+				host
+			};
+			try {
+				register(session);
+			} catch (error) {
+				if (sessions.get(id)?.host === host) try {
+					unregisterSession(id);
+				} catch (cleanupError) {
+					options.onNotice?.(`Session '${id}' registration rollback failed: ${String(cleanupError)}`);
+				}
+				await Promise.resolve(options.manager.closeSession(id)).catch((closeError) => options.onNotice?.(`Session '${id}' could not be closed after a failed registration: ${String(closeError)}`));
+				throw error;
+			}
+			return session;
+		},
+		closeSession,
+		async requestSessionApi(scope, request) {
+			if (closed || !sessions.has(scope.sessionId)) return Response.json({ error: "Session not found." }, { status: 404 });
+			if (options.requestSessionApi === void 0) return Response.json({ error: "Session API unavailable." }, { status: 404 });
+			return options.requestSessionApi(scope, request);
+		},
+		registerChannel(channel, mount = { scope: "global" }) {
+			const started = startChannel(channel, mount);
+			if (started === void 0) return () => void 0;
+			return () => releaseChannel(channel, started);
+		},
+		channelTypes: () => [...new Set([...channels.values()].map(({ channel }) => channel.frameType))],
+		channelFrames(sessionId) {
+			const session = sessions.get(sessionId);
+			if (session === void 0) return [];
+			const scope = scopeOf(session);
+			const frames = [];
+			for (const { channel, source } of selectedChannels(session)) {
+				const type = channel.frameType;
+				const payload = source.payloadFor(scope);
+				if (payload !== void 0) frames.push({
+					type,
+					sessionId,
+					payload
+				});
+			}
+			return frames;
+		},
+		threadJournal(sessionId, threadId) {
+			const session = sessions.get(sessionId);
+			if (session === void 0) return void 0;
+			const scope = scopeOf(session);
+			for (const { source } of selectedChannels(session)) {
+				const journal = source.threadJournal?.(scope, threadId);
+				if (journal !== void 0) return journal;
+			}
+		},
+		receiveChannel(sessionId, frameType, payload, connectionId, desktopAuthorized = false, computerUseAuthorized = false) {
+			if (connectionId === "") return;
+			const session = sessions.get(sessionId);
+			const started = session && selectedChannels(session).find(({ channel }) => channel.frameType === frameType);
+			if (session === void 0 || started === void 0) return;
+			started.channel.receive?.(scopeOf(session), payload, {
+				connectionId,
+				...desktopAuthorized ? { desktopAuthorized: true } : {},
+				...computerUseAuthorized ? { computerUseAuthorized: true } : {}
+			});
+		},
+		disconnectChannels(connectionId) {
+			if (connectionId === "") return;
+			for (const { channel } of channels.values()) channel.disconnected?.({ connectionId });
+		},
+		async close() {
+			if (closed) return;
+			const ids = [...sessions.keys()];
+			closed = true;
+			directEvents.close();
+			for (const unsubscribe of subscriptions) unsubscribe();
+			subscriptions.clear();
+			for (const cleanup of presentationCleanups.values()) cleanup();
+			presentationCleanups.clear();
+			const failures = [];
+			for (const mounted of [...mounts.values()].reverse()) {
+				try {
+					await mounted.installed.dispose();
+				} catch (error) {
+					failures.push(error);
+				}
+				try {
+					mounted.host.dispose();
+				} catch (error) {
+					failures.push(error);
+				}
+			}
+			mounts.clear();
+			pluginRegistry.dispose();
+			workspaces.clear();
+			for (const { source } of channels.values()) source.close();
+			channels.clear();
+			listeners.clear();
+			const shutdowns = [...sessionShutdowns.values()].filter(({ pending }) => pending).map(({ promise }) => promise);
+			for (const id of ids) {
+				const session = sessions.get(id);
+				if (session !== void 0 && !sessionShutdowns.has(id)) shutdowns.push(startSessionShutdown(session));
+			}
+			sessions.clear();
+			const outcomes = await Promise.allSettled(shutdowns);
+			for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
+			if (failures.length) throw new AggregateError(failures, "Mount shutdown failed");
+		}
+	};
+}
+//#endregion
+export { createHeadlessHub };
+
+//# sourceMappingURL=headlessHub.mjs.map