@treeport/treeport 0.6.1 → 0.7.0

package/dist/node/server/terminal-host-entry.js

@@ -0,0 +1,962 @@
+import { an as parseTerminalProgress } from "../../dist-BsLn2Gbc.js";
+import { i as terminalHostRecordSchema, n as encodeTerminalHostFrame, o as makeHostTraceRuntime, r as terminalHostInputSchemas, t as TerminalHostFrameDecoder } from "../../terminal-host-protocol-DZkQRAUF.js";
+import { n as prepareShellIntegration, t as integrateShellLaunch } from "../../shell-integration-CPmrVa3B.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import { promisify } from "node:util";
+import net from "node:net";
+import { SerializeAddon } from "@xterm/addon-serialize";
+import xtermHeadless from "@xterm/headless";
+import * as pty from "node-pty";
+//#region src/server/core/terminal.ts
+const TERMINAL_PROGRESS_STALE_MS = 5 * 6e4;
+//#endregion
+//#region src/server/terminal-host-sessions.ts
+const { Terminal } = xtermHeadless;
+const HOST_SCROLLBACK_LINES = 5e4;
+const HOST_PARSER_HIGH_WATERMARK = 1024 * 1024;
+const HOST_PARSER_LOW_WATERMARK = 256 * 1024;
+const PROCESS_TREE_KILL_GRACE_MS = 500;
+const execute = promisify(execFile);
+async function descendantPids(rootPid) {
+	const rows = await execute("ps", ["-axo", "pid=,ppid="]).then(({ stdout }) => stdout.split("\n").map((line) => line.trim().split(/\s+/u).map(Number)).filter((row) => row.length === 2 && row.every(Number.isInteger))).catch(() => []);
+	const children = /* @__PURE__ */ new Map();
+	for (const [pid, parentPid] of rows) children.set(parentPid, [...children.get(parentPid) ?? [], pid]);
+	const descendants = [];
+	const pending = [...children.get(rootPid) ?? []];
+	while (pending.length) {
+		const pid = pending.pop();
+		descendants.push(pid);
+		pending.push(...children.get(pid) ?? []);
+	}
+	return descendants;
+}
+function signalPid(pid, signal) {
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch (error) {
+		if (error.code === "ESRCH") return false;
+		throw error;
+	}
+}
+async function terminatePtyProcessTree(child) {
+	const descendants = await descendantPids(child.pid);
+	const signalTree = (signal) => {
+		const groupSignaled = signalPid(-child.pid, signal);
+		for (const pid of [...descendants].reverse()) signalPid(pid, signal);
+		if (!groupSignaled) child.kill(signal);
+	};
+	signalTree("SIGTERM");
+	await new Promise((resolve) => setTimeout(resolve, PROCESS_TREE_KILL_GRACE_MS));
+	signalTree("SIGKILL");
+}
+/**
+* Detached owner of one PTY and one canonical emulator per terminal.
+*
+* The headless emulator answers terminal queries while no browser controller
+* owns that authority. Authority changes use a paused parser boundary so two
+* emulators never answer the same query.
+*/
+var TerminalHostSessionManager = class {
+	runtimeDir;
+	launcherPath;
+	spawnPty;
+	terminateProcessTree;
+	progressStaleMs;
+	shellIntegrationDir;
+	sessions = /* @__PURE__ */ new Map();
+	pendingCleanups = /* @__PURE__ */ new Set();
+	initialization = null;
+	constructor(runtimeDir, launcherPath, spawnPty = pty.spawn, terminateProcessTree = terminatePtyProcessTree, progressStaleMs = TERMINAL_PROGRESS_STALE_MS) {
+		this.runtimeDir = runtimeDir;
+		this.launcherPath = launcherPath;
+		this.spawnPty = spawnPty;
+		this.terminateProcessTree = terminateProcessTree;
+		this.progressStaleMs = progressStaleMs;
+		this.shellIntegrationDir = path.join(runtimeDir, "terminal-shell-integration");
+	}
+	initialize() {
+		this.initialization ??= Promise.all([fs.mkdir(path.join(this.runtimeDir, "terminal-specs"), {
+			recursive: true,
+			mode: 448
+		}), prepareShellIntegration(this.shellIntegrationDir)]).then(() => void 0);
+		return this.initialization.then(() => true);
+	}
+	async createTerminal(input) {
+		await this.initialize();
+		if (this.sessions.has(input.terminalId)) throw new Error(`Terminal already exists: ${input.terminalId}`);
+		const directShell = input.interactiveShell && input.shellCommand === null && !input.initialTitle && !input.fallbackArgv && !input.setupTasks?.length && !input.setupError;
+		let specPath = null;
+		if (!directShell) {
+			const spec = {
+				argv: [...input.argv],
+				cwd: input.cwd,
+				env: { ...input.env },
+				shellIntegrationDir: this.shellIntegrationDir
+			};
+			if (input.initialTitle) spec.initialTitle = input.initialTitle;
+			if (input.fallbackArgv) spec.fallbackArgv = [...input.fallbackArgv];
+			if (input.setupTasks) spec.setupTasks = input.setupTasks;
+			if (input.setupError) spec.setupError = input.setupError;
+			specPath = path.join(this.runtimeDir, "terminal-specs", `${input.terminalId}-${crypto.randomUUID()}.json`);
+			await fs.writeFile(specPath, JSON.stringify(spec), { mode: 384 });
+		}
+		const size = input.initialSize ?? {
+			cols: 100,
+			rows: 30
+		};
+		const inheritedEnvironment = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0));
+		inheritedEnvironment.TERM = "xterm-256color";
+		const directLaunch = integrateShellLaunch(input.argv, {
+			...inheritedEnvironment,
+			...input.env
+		}, this.shellIntegrationDir, directShell);
+		const directEnvironment = Object.fromEntries(Object.entries(directLaunch.env).filter((entry) => entry[1] !== void 0));
+		const terminal = new Terminal({
+			cols: size.cols,
+			rows: size.rows,
+			scrollback: HOST_SCROLLBACK_LINES,
+			allowProposedApi: true,
+			disableStdin: false
+		});
+		const serializer = new SerializeAddon();
+		terminal.loadAddon(serializer);
+		let child;
+		try {
+			child = directShell ? this.spawnPty(directLaunch.argv[0], directLaunch.argv.slice(1), {
+				name: "xterm-256color",
+				cols: size.cols,
+				rows: size.rows,
+				cwd: input.cwd,
+				env: directEnvironment
+			}) : this.spawnPty(process.execPath, [this.launcherPath, specPath], {
+				name: "xterm-256color",
+				cols: size.cols,
+				rows: size.rows,
+				cwd: input.cwd,
+				env: inheritedEnvironment
+			});
+		} catch (error) {
+			serializer.dispose();
+			terminal.dispose();
+			if (specPath) await fs.rm(specPath, { force: true });
+			throw error;
+		}
+		const outputListeners = /* @__PURE__ */ new Set();
+		const runtimeListeners = /* @__PURE__ */ new Set();
+		const session = {
+			id: input.terminalId,
+			worktreeId: input.worktreeId,
+			name: input.name,
+			argv: [...input.argv],
+			shellCommand: input.shellCommand,
+			interactiveShell: input.interactiveShell,
+			closeOnSuccess: input.closeOnSuccess ?? false,
+			status: "running",
+			exitCode: null,
+			createdAt: input.createdAt,
+			updatedAt: input.createdAt,
+			cwd: input.cwd,
+			specPath,
+			title: input.initialTitle ?? null,
+			commandLine: input.initialTitle ?? null,
+			progress: null,
+			progressLease: null,
+			bellSequence: 0,
+			lastBellAt: null,
+			pty: child,
+			terminal,
+			serializer,
+			outputSequence: 0,
+			parserQueue: [],
+			parserQueuedBytes: 0,
+			parserWriting: false,
+			parserPaused: false,
+			parserWaiters: /* @__PURE__ */ new Set(),
+			boundaryPauseCount: 0,
+			queryAuthorityAttachmentId: null,
+			queryAuthorityGeneration: null,
+			queryTransitionId: null,
+			outputListeners,
+			runtimeListeners,
+			dataDisposable: null,
+			exitDisposable: null
+		};
+		terminal.onData((data) => {
+			if (session.status === "running" && session.queryAuthorityAttachmentId === null) session.pty.write(data);
+		});
+		terminal.onTitleChange((title) => {
+			session.title = title;
+			for (const listener of runtimeListeners) listener({
+				title,
+				titleState: {
+					terminalTitle: title,
+					currentCommand: session.pty.process || null,
+					commandLine: session.commandLine
+				}
+			});
+		});
+		terminal.onBell(() => {
+			session.bellSequence += 1;
+			session.lastBellAt = (/* @__PURE__ */ new Date()).toISOString();
+			for (const listener of runtimeListeners) listener({ bell: {
+				sequence: session.bellSequence,
+				at: session.lastBellAt
+			} });
+		});
+		terminal.parser.registerOscHandler(777, (payload) => {
+			if (!payload.startsWith("command;")) return false;
+			session.commandLine = payload.slice(8).replace(/\p{Cc}/gu, "").trim().slice(0, 256) || null;
+			const titleState = {
+				terminalTitle: session.title,
+				currentCommand: session.pty.process || null,
+				commandLine: session.commandLine
+			};
+			for (const listener of runtimeListeners) listener({ titleState });
+			return true;
+		});
+		terminal.parser.registerOscHandler(9, (payload) => {
+			const progress = parseTerminalProgress(payload);
+			if (progress === void 0) return false;
+			if (session.progressLease) {
+				clearTimeout(session.progressLease);
+				session.progressLease = null;
+			}
+			session.progress = progress;
+			if (progress !== null) {
+				session.progressLease = setTimeout(() => {
+					session.progressLease = null;
+					if (this.sessions.get(session.id) !== session) return;
+					session.progress = null;
+					for (const listener of runtimeListeners) listener({ progress: null });
+				}, this.progressStaleMs);
+				session.progressLease.unref();
+			}
+			for (const listener of runtimeListeners) listener({ progress });
+			return true;
+		});
+		this.sessions.set(input.terminalId, session);
+		session.dataDisposable = child.onData((data) => {
+			const bytes = Buffer.byteLength(data);
+			session.parserQueue.push({
+				data,
+				sequence: ++session.outputSequence,
+				bytes
+			});
+			session.parserQueuedBytes += bytes;
+			if (!session.parserPaused && session.parserQueuedBytes >= HOST_PARSER_HIGH_WATERMARK) {
+				session.parserPaused = true;
+				session.pty.pause();
+			}
+			this.parseNext(session);
+		});
+		session.exitDisposable = child.onExit(({ exitCode }) => {
+			if (session.progressLease) {
+				clearTimeout(session.progressLease);
+				session.progressLease = null;
+			}
+			session.progress = null;
+			session.status = "exited";
+			for (const resolve of session.parserWaiters) resolve();
+			session.parserWaiters.clear();
+			session.exitCode = exitCode;
+			session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			for (const listener of [...runtimeListeners]) listener({ exitCode });
+			if (specPath) fs.rm(specPath, { force: true }).catch((error) => {
+				console.error(`[Treeport terminal host] Failed to remove launch spec ${specPath}:`, error instanceof Error ? error.message : String(error));
+			});
+		});
+	}
+	get sessionCount() {
+		return this.sessions.size;
+	}
+	size(terminalId) {
+		const session = this.sessions.get(terminalId);
+		return session ? {
+			cols: session.terminal.cols,
+			rows: session.terminal.rows
+		} : null;
+	}
+	runtimeState(terminalId) {
+		const session = this.sessions.get(terminalId);
+		return session ? {
+			title: session.title,
+			status: session.status,
+			progress: session.progress,
+			bell: session.lastBellAt === null ? null : {
+				sequence: session.bellSequence,
+				at: session.lastBellAt
+			}
+		} : null;
+	}
+	async snapshot(terminalId) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return null;
+		this.pauseBoundary(session);
+		try {
+			await this.drainParser(session);
+			if (this.sessions.get(terminalId) !== session) return null;
+			const links = [];
+			const terminalInternals = Object(session.terminal);
+			for (const [bufferName, buffer] of [["normal", session.terminal.buffer.normal], ["alternate", session.terminal.buffer.alternate]]) for (let lineIndex = 0; lineIndex < buffer.length; lineIndex += 1) {
+				const line = buffer.getLine(lineIndex);
+				if (!line) continue;
+				let activeLink = null;
+				for (let column = 0; column <= line.length; column += 1) {
+					const cell = column < line.length ? line.getCell(column) : void 0;
+					const linkId = (cell ? Object(cell) : void 0)?.extended?.urlId;
+					if (activeLink !== null && linkId === activeLink.id) continue;
+					if (activeLink) {
+						const data = terminalInternals._core._oscLinkService.getLinkData(activeLink.id);
+						if (data?.uri && data.uri.length <= 4096 && links.length < 1e4) links.push({
+							buffer: bufferName,
+							uri: data.uri,
+							line: lineIndex,
+							startColumn: activeLink.startColumn,
+							endColumn: column
+						});
+					}
+					activeLink = linkId ? {
+						id: linkId,
+						startColumn: column
+					} : null;
+				}
+			}
+			return {
+				data: session.serializer.serialize({ scrollback: HOST_SCROLLBACK_LINES }),
+				links,
+				fence: session.outputSequence,
+				cols: session.terminal.cols,
+				rows: session.terminal.rows
+			};
+		} finally {
+			this.releaseBoundary(session);
+		}
+	}
+	subscribeOutput(terminalId, listener) {
+		const session = this.sessions.get(terminalId);
+		if (!session) throw new Error("Terminal is unavailable");
+		session.outputListeners.add(listener);
+		return () => session.outputListeners.delete(listener);
+	}
+	subscribeRuntime(terminalId, listener) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return () => void 0;
+		session.runtimeListeners.add(listener);
+		return () => session.runtimeListeners.delete(listener);
+	}
+	async write(terminalId, data, authority) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status !== "running" || session.queryAuthorityAttachmentId !== authority.attachmentId || session.queryAuthorityGeneration !== authority.generation || session.queryTransitionId !== null) return;
+		session.pty.write(data);
+	}
+	async prepareQueryAuthority(terminalId) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status !== "running") throw new Error("Terminal is unavailable");
+		if (session.queryTransitionId !== null) throw new Error("A terminal query authority change is already pending");
+		this.pauseBoundary(session);
+		await this.drainParser(session);
+		if (this.sessions.get(terminalId) !== session) throw new Error("Terminal is unavailable");
+		session.queryAuthorityAttachmentId = null;
+		session.queryAuthorityGeneration = null;
+		session.terminal.options.disableStdin = false;
+		session.queryTransitionId = crypto.randomUUID();
+		return {
+			transitionId: session.queryTransitionId,
+			fence: session.outputSequence
+		};
+	}
+	async activateQueryAuthority(terminalId, transitionId, attachmentId, generation) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status !== "running" || session.queryTransitionId !== transitionId) throw new Error("Terminal query authority transition is unavailable");
+		session.terminal.options.disableStdin = true;
+		session.queryAuthorityAttachmentId = attachmentId;
+		session.queryAuthorityGeneration = generation;
+		session.queryTransitionId = null;
+		this.releaseBoundary(session);
+	}
+	async useHostQueryAuthority(terminalId) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status !== "running") return;
+		if (session.queryTransitionId === null) {
+			this.pauseBoundary(session);
+			await this.drainParser(session);
+			if (this.sessions.get(terminalId) !== session) return;
+		}
+		session.terminal.options.disableStdin = false;
+		session.queryAuthorityAttachmentId = null;
+		session.queryAuthorityGeneration = null;
+		if (session.queryTransitionId !== null) session.queryTransitionId = null;
+		this.releaseBoundary(session);
+	}
+	async restoreHostQueryAuthority() {
+		await Promise.all([...this.sessions.keys()].map((terminalId) => this.useHostQueryAuthority(terminalId)));
+	}
+	async resize(terminalId, cols, rows) {
+		const session = this.sessions.get(terminalId);
+		if (!session || session.status !== "running") return;
+		this.pauseBoundary(session);
+		try {
+			await this.drainParser(session);
+			if (this.sessions.get(terminalId) !== session) return;
+			session.pty.resize(cols, rows);
+			session.terminal.resize(cols, rows);
+		} finally {
+			this.releaseBoundary(session);
+		}
+	}
+	async listTerminals(worktreeId) {
+		return [...this.sessions.values()].filter((session) => session.worktreeId === worktreeId).map(({ pty: _pty, terminal: _terminal, serializer: _serializer, dataDisposable: _data, exitDisposable: _exit, outputSequence: _outputSequence, parserQueue: _parserQueue, parserQueuedBytes: _parserQueuedBytes, parserWriting: _parserWriting, parserPaused: _parserPaused, parserWaiters: _parserWaiters, boundaryPauseCount: _boundaryPauseCount, queryAuthorityAttachmentId: _queryAuthorityAttachmentId, queryAuthorityGeneration: _queryAuthorityGeneration, queryTransitionId: _queryTransitionId, outputListeners: _outputs, runtimeListeners: _runtime, cwd: _cwd, specPath: _specPath, title: _title, commandLine: _commandLine, progress: _progress, progressLease: _progressLease, bellSequence: _bellSequence, lastBellAt: _lastBellAt, ...terminal }) => ({ ...terminal }));
+	}
+	async terminalState(terminalId) {
+		const session = this.sessions.get(terminalId);
+		return session ? {
+			status: session.status,
+			exitCode: session.exitCode
+		} : {
+			status: "missing",
+			exitCode: null
+		};
+	}
+	async terminalSize(terminalId) {
+		const session = this.sessions.get(terminalId);
+		return session ? {
+			cols: session.terminal.cols,
+			rows: session.terminal.rows
+		} : null;
+	}
+	async captureTerminal(terminalId, lines) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return null;
+		await new Promise((resolve) => session.terminal.write("", resolve));
+		const buffer = session.terminal.buffer.active;
+		const content = [];
+		for (let index = 0; index < buffer.length; index += 1) content.push(buffer.getLine(index)?.translateToString(true) ?? "");
+		while (content.length && !content.at(-1)?.trim()) content.pop();
+		return content.slice(-lines).join("\n");
+	}
+	async renameTerminal(terminalId, name, updatedAt) {
+		const session = this.sessions.get(terminalId);
+		if (session) {
+			session.name = name;
+			session.updatedAt = updatedAt;
+		}
+	}
+	async listProcesses(worktreeId) {
+		return [...this.sessions.values()].filter((session) => session.worktreeId === worktreeId && session.status === "running").map((session) => ({
+			pid: session.pty.pid,
+			terminalId: session.id
+		}));
+	}
+	async terminalTitleState(terminalId) {
+		const session = this.sessions.get(terminalId);
+		if (!session) return null;
+		return {
+			terminalTitle: session.title,
+			currentCommand: session.pty.process || null,
+			commandLine: session.commandLine
+		};
+	}
+	async signalTerminal(terminalId, signal) {
+		const session = this.sessions.get(terminalId);
+		if (session?.status === "running") session.pty.kill(signal);
+	}
+	async killTerminal(terminalId) {
+		const session = this.sessions.get(terminalId);
+		if (session) await this.destroy(session);
+	}
+	async killWorktree(worktreeId) {
+		const sessions = [...this.sessions.values()].filter((session) => session.worktreeId === worktreeId);
+		const terminalIds = sessions.map((session) => session.id);
+		const started = sessions.map((session) => this.destroy(session));
+		const alreadyPending = [...this.pendingCleanups].filter((cleanup) => cleanup.worktreeId === worktreeId).map((cleanup) => cleanup.promise);
+		await Promise.all([...started, ...alreadyPending]);
+		return terminalIds;
+	}
+	async shutdown() {
+		const started = [...this.sessions.values()].map((session) => this.destroy(session));
+		await Promise.all([...started, ...[...this.pendingCleanups].map((cleanup) => cleanup.promise)]);
+	}
+	parseNext(session) {
+		if (session.parserWriting || this.sessions.get(session.id) !== session) return;
+		const next = session.parserQueue.shift();
+		if (!next) {
+			for (const resolve of session.parserWaiters) resolve();
+			session.parserWaiters.clear();
+			return;
+		}
+		session.parserWriting = true;
+		session.terminal.write(next.data, () => {
+			if (this.sessions.get(session.id) !== session) return;
+			session.parserWriting = false;
+			session.parserQueuedBytes = Math.max(0, session.parserQueuedBytes - next.bytes);
+			for (const listener of [...session.outputListeners]) listener(next.data, next.sequence);
+			if (session.parserPaused && session.parserQueuedBytes <= HOST_PARSER_LOW_WATERMARK) {
+				session.parserPaused = false;
+				if (session.boundaryPauseCount === 0) session.pty.resume();
+			}
+			this.parseNext(session);
+		});
+	}
+	drainParser(session) {
+		if (!session.parserWriting && session.parserQueue.length === 0) return Promise.resolve();
+		return new Promise((resolve) => session.parserWaiters.add(resolve));
+	}
+	pauseBoundary(session) {
+		session.boundaryPauseCount += 1;
+		if (session.boundaryPauseCount === 1) session.pty.pause();
+	}
+	releaseBoundary(session) {
+		session.boundaryPauseCount = Math.max(0, session.boundaryPauseCount - 1);
+		if (this.sessions.get(session.id) === session && session.status === "running" && session.boundaryPauseCount === 0 && !session.parserPaused) session.pty.resume();
+	}
+	destroy(session) {
+		if (this.sessions.get(session.id) !== session) return Promise.resolve();
+		this.sessions.delete(session.id);
+		session.dataDisposable?.dispose();
+		session.exitDisposable?.dispose();
+		if (session.progressLease) {
+			clearTimeout(session.progressLease);
+			session.progressLease = null;
+		}
+		session.outputListeners.clear();
+		session.runtimeListeners.clear();
+		for (const resolve of session.parserWaiters) resolve();
+		session.parserWaiters.clear();
+		session.parserQueue = [];
+		session.serializer.dispose();
+		session.terminal.dispose();
+		const physicalCleanup = Promise.all([session.specPath ? fs.rm(session.specPath, { force: true }) : Promise.resolve(), this.terminateProcessTree(session.pty)]).then(() => void 0);
+		const ownedCleanup = {
+			worktreeId: session.worktreeId,
+			promise: physicalCleanup
+		};
+		const cleanup = physicalCleanup.finally(() => this.pendingCleanups.delete(ownedCleanup));
+		ownedCleanup.promise = cleanup;
+		this.pendingCleanups.add(ownedCleanup);
+		cleanup.catch(() => void 0);
+		return cleanup;
+	}
+};
+//#endregion
+//#region src/server/terminal-host-server.ts
+const TERMINAL_HOST_MAX_QUEUED_BYTES = 4 * 1024 * 1024;
+function tokensMatch(actual, expected) {
+	const actualBuffer = Buffer.from(actual);
+	const expectedBuffer = Buffer.from(expected);
+	return actualBuffer.byteLength === expectedBuffer.byteLength && crypto.timingSafeEqual(actualBuffer, expectedBuffer);
+}
+async function startTerminalHostServer(options) {
+	await options.sessions.initialize();
+	const record = {
+		protocolVersion: 3,
+		hostId: options.hostId,
+		hostKey: options.hostKey,
+		pid: options.pid ?? process.pid,
+		socketPath: options.socketPath,
+		startedAt: options.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const connections = /* @__PURE__ */ new Set();
+	let closing = false;
+	let shuttingDown = false;
+	const send = (connection, frame) => {
+		if (connection.socket.destroyed) return false;
+		const encoded = encodeTerminalHostFrame(frame);
+		if (connection.writeBlocked) {
+			if (connection.queuedBytes + encoded.byteLength > TERMINAL_HOST_MAX_QUEUED_BYTES) {
+				connection.socket.destroy();
+				return false;
+			}
+			const queuedFrame = {
+				encoded,
+				next: null
+			};
+			if (connection.queuedFrameTail) connection.queuedFrameTail.next = queuedFrame;
+			else connection.queuedFrameHead = queuedFrame;
+			connection.queuedFrameTail = queuedFrame;
+			connection.queuedBytes += encoded.byteLength;
+			return true;
+		}
+		try {
+			connection.writeBlocked = !connection.socket.write(encoded);
+			return true;
+		} catch {
+			connection.socket.destroy();
+			return false;
+		}
+	};
+	const flush = (connection) => {
+		if (connection.socket.destroyed) return;
+		connection.writeBlocked = false;
+		while (connection.queuedFrameHead) {
+			const queuedFrame = connection.queuedFrameHead;
+			connection.queuedFrameHead = queuedFrame.next;
+			if (!connection.queuedFrameHead) connection.queuedFrameTail = null;
+			connection.queuedBytes -= queuedFrame.encoded.byteLength;
+			try {
+				if (!connection.socket.write(queuedFrame.encoded)) {
+					connection.writeBlocked = true;
+					return;
+				}
+			} catch {
+				connection.socket.destroy();
+				return;
+			}
+		}
+	};
+	const respond = (connection, id, result) => send(connection, {
+		protocolVersion: 3,
+		type: "response",
+		id,
+		result,
+		error: null
+	});
+	const fail = (connection, id, code, message, details = {}) => send(connection, {
+		protocolVersion: 3,
+		type: "response",
+		id,
+		result: null,
+		error: {
+			code,
+			message,
+			...details
+		}
+	});
+	const handleRequest = async (connection, frame) => {
+		if (frame.protocolVersion !== 3) {
+			fail(connection, frame.id, "INCOMPATIBLE_PROTOCOL", `Terminal host protocol 3 is not compatible with daemon protocol ${frame.protocolVersion}`, {
+				hostProtocolVersion: 3,
+				liveSessionCount: options.sessions.sessionCount
+			});
+			return;
+		}
+		if (!connection.authenticated) {
+			if (frame.method !== "handshake") {
+				fail(connection, frame.id, "AUTH_REQUIRED", "Handshake is required");
+				connection.socket.destroy();
+				return;
+			}
+			const input = terminalHostInputSchemas.handshake.parse(frame.input);
+			if (!tokensMatch(input.token ?? "", options.token)) {
+				fail(connection, frame.id, "AUTH_FAILED", "Authentication failed");
+				connection.socket.destroy();
+				return;
+			}
+			if (input.hostKey !== options.hostKey) {
+				fail(connection, frame.id, "HOST_MISMATCH", "Terminal host key differs");
+				connection.socket.destroy();
+				return;
+			}
+			if (input.protocolVersion !== 3) {
+				fail(connection, frame.id, "INCOMPATIBLE_PROTOCOL", `Terminal host protocol 3 is not compatible with daemon protocol ${input.protocolVersion}`, {
+					hostProtocolVersion: 3,
+					liveSessionCount: options.sessions.sessionCount
+				});
+				return;
+			}
+			connection.authenticated = true;
+			respond(connection, frame.id, {
+				...record,
+				liveSessionCount: options.sessions.sessionCount,
+				traceContext: true
+			});
+			return;
+		}
+		if (shuttingDown) {
+			fail(connection, frame.id, "HOST_SHUTTING_DOWN", "The terminal host is shutting down");
+			return;
+		}
+		switch (frame.method) {
+			case "handshake":
+				fail(connection, frame.id, "ALREADY_AUTHENTICATED", "Handshake is complete");
+				return;
+			case "create":
+				await options.sessions.createTerminal(terminalHostInputSchemas.create.parse(frame.input));
+				respond(connection, frame.id, null);
+				return;
+			case "inventory": {
+				const input = terminalHostInputSchemas.inventory.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.listTerminals(input.worktreeId));
+				return;
+			}
+			case "state": {
+				const input = terminalHostInputSchemas.state.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.terminalState(input.terminalId));
+				return;
+			}
+			case "attach": {
+				const input = terminalHostInputSchemas.attach.parse(frame.input);
+				connection.outputUnsubscribes.get(input.terminalId)?.();
+				const unsubscribe = options.sessions.subscribeOutput(input.terminalId, (output, sequence) => {
+					send(connection, {
+						protocolVersion: 3,
+						type: "event",
+						event: "output",
+						data: {
+							terminalId: input.terminalId,
+							output,
+							sequence
+						}
+					});
+				});
+				connection.outputUnsubscribes.set(input.terminalId, unsubscribe);
+				const snapshot = await options.sessions.snapshot(input.terminalId);
+				if (snapshot === null) {
+					unsubscribe();
+					connection.outputUnsubscribes.delete(input.terminalId);
+				}
+				respond(connection, frame.id, snapshot);
+				return;
+			}
+			case "unsubscribeOutput": {
+				const input = terminalHostInputSchemas.unsubscribeOutput.parse(frame.input);
+				connection.outputUnsubscribes.get(input.terminalId)?.();
+				connection.outputUnsubscribes.delete(input.terminalId);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "subscribeRuntime": {
+				const input = terminalHostInputSchemas.subscribeRuntime.parse(frame.input);
+				connection.runtimeUnsubscribes.get(input.terminalId)?.();
+				connection.runtimeUnsubscribes.set(input.terminalId, options.sessions.subscribeRuntime(input.terminalId, (value) => {
+					send(connection, {
+						protocolVersion: 3,
+						type: "event",
+						event: "runtime",
+						data: {
+							terminalId: input.terminalId,
+							value
+						}
+					});
+				}));
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "unsubscribeRuntime": {
+				const input = terminalHostInputSchemas.unsubscribeRuntime.parse(frame.input);
+				connection.runtimeUnsubscribes.get(input.terminalId)?.();
+				connection.runtimeUnsubscribes.delete(input.terminalId);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "runtimeState": {
+				const input = terminalHostInputSchemas.runtimeState.parse(frame.input);
+				respond(connection, frame.id, options.sessions.runtimeState(input.terminalId));
+				return;
+			}
+			case "write": {
+				const input = terminalHostInputSchemas.write.parse(frame.input);
+				options.sessions.write(input.terminalId, input.encoding === "base64" ? Buffer.from(input.data, "base64") : input.data, input.authority);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "prepareQueryAuthority": {
+				const input = terminalHostInputSchemas.prepareQueryAuthority.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.prepareQueryAuthority(input.terminalId));
+				return;
+			}
+			case "activateQueryAuthority": {
+				const input = terminalHostInputSchemas.activateQueryAuthority.parse(frame.input);
+				await options.sessions.activateQueryAuthority(input.terminalId, input.transitionId, input.attachmentId, input.generation);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "hostQueryAuthority": {
+				const input = terminalHostInputSchemas.hostQueryAuthority.parse(frame.input);
+				await options.sessions.useHostQueryAuthority(input.terminalId);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "resize": {
+				const input = terminalHostInputSchemas.resize.parse(frame.input);
+				await options.sessions.resize(input.terminalId, input.cols, input.rows);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "capture": {
+				const input = terminalHostInputSchemas.capture.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.captureTerminal(input.terminalId, input.lines));
+				return;
+			}
+			case "rename": {
+				const input = terminalHostInputSchemas.rename.parse(frame.input);
+				await options.sessions.renameTerminal(input.terminalId, input.name, input.updatedAt);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "processes": {
+				const input = terminalHostInputSchemas.processes.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.listProcesses(input.worktreeId));
+				return;
+			}
+			case "titleState": {
+				const input = terminalHostInputSchemas.titleState.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.terminalTitleState(input.terminalId));
+				return;
+			}
+			case "signal": {
+				const input = terminalHostInputSchemas.signal.parse(frame.input);
+				await options.sessions.signalTerminal(input.terminalId, input.signal);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "kill": {
+				const input = terminalHostInputSchemas.kill.parse(frame.input);
+				await options.sessions.killTerminal(input.terminalId);
+				respond(connection, frame.id, null);
+				return;
+			}
+			case "killWorktree": {
+				const input = terminalHostInputSchemas.killWorktree.parse(frame.input);
+				respond(connection, frame.id, await options.sessions.killWorktree(input.worktreeId));
+				return;
+			}
+			case "shutdown":
+				terminalHostInputSchemas.shutdown.parse(frame.input);
+				if (options.sessions.sessionCount > 0) {
+					fail(connection, frame.id, "HOST_NOT_EMPTY", "The terminal host still owns live or exited sessions", { liveSessionCount: options.sessions.sessionCount });
+					return;
+				}
+				shuttingDown = true;
+				await options.sessions.shutdown().catch((error) => {
+					shuttingDown = false;
+					throw error;
+				});
+				respond(connection, frame.id, null);
+				setImmediate(() => {
+					close().then(() => options.onShutdown?.()).catch((error) => {
+						console.error("[Treeport terminal host] Requested shutdown failed:", error instanceof Error ? error.message : String(error));
+					});
+				});
+		}
+	};
+	const server = net.createServer((socket) => {
+		socket.setNoDelay(true);
+		const connection = {
+			socket,
+			authenticated: false,
+			decoder: new TerminalHostFrameDecoder(),
+			outputUnsubscribes: /* @__PURE__ */ new Map(),
+			runtimeUnsubscribes: /* @__PURE__ */ new Map(),
+			requestTail: Promise.resolve(),
+			writeBlocked: false,
+			queuedFrameHead: null,
+			queuedFrameTail: null,
+			queuedBytes: 0
+		};
+		connections.add(connection);
+		const release = () => {
+			connections.delete(connection);
+			connection.queuedFrameHead = null;
+			connection.queuedFrameTail = null;
+			connection.queuedBytes = 0;
+			for (const unsubscribe of connection.outputUnsubscribes.values()) unsubscribe();
+			for (const unsubscribe of connection.runtimeUnsubscribes.values()) unsubscribe();
+			connection.outputUnsubscribes.clear();
+			connection.runtimeUnsubscribes.clear();
+			if (connection.authenticated) options.sessions.restoreHostQueryAuthority().catch((error) => {
+				console.error("[Treeport terminal host] Failed to restore query authority after a client disconnected:", error instanceof Error ? error.message : String(error));
+			});
+		};
+		socket.once("close", release);
+		socket.on("error", () => void 0);
+		socket.on("drain", () => flush(connection));
+		socket.on("data", (chunk) => {
+			let frames;
+			try {
+				frames = connection.decoder.push(chunk);
+			} catch {
+				socket.destroy();
+				return;
+			}
+			for (const frame of frames) {
+				if (frame.type !== "request") {
+					socket.destroy();
+					return;
+				}
+				const admittedAt = Date.now();
+				const run = () => {
+					const evaluate = () => handleRequest(connection, frame);
+					return (frame.trace && options.trace ? options.trace(frame.method === "create" ? "treeport.terminal_host.pty.create" : frame.method === "attach" ? "treeport.terminal_host.attach" : frame.method === "kill" ? "treeport.terminal_host.pty.remove" : "treeport.terminal_host.request", frame.trace, {
+						"treeport.terminal_host.method": frame.method,
+						"treeport.terminal_host.queue_wait_ms": Date.now() - admittedAt
+					}, evaluate) : evaluate()).catch((error) => {
+						fail(connection, frame.id, "REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+					});
+				};
+				if (connection.authenticated && frame.method === "kill") connection.requestTail.then(run);
+				else connection.requestTail = connection.requestTail.then(run);
+			}
+		});
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(options.socketPath, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	await fs.chmod(options.socketPath, 384);
+	const temporaryRecordPath = `${options.recordPath}.${process.pid}.tmp`;
+	await fs.writeFile(temporaryRecordPath, `${JSON.stringify(record)}\n`, { mode: 384 });
+	await fs.rename(temporaryRecordPath, options.recordPath);
+	async function close() {
+		if (closing) return;
+		closing = true;
+		for (const connection of connections) connection.socket.destroy();
+		await new Promise((resolve) => server.close(() => resolve()));
+		if (await fs.readFile(options.recordPath, "utf8").then((value) => {
+			const parsed = terminalHostRecordSchema.safeParse(JSON.parse(value));
+			return parsed.success && parsed.data.hostId === options.hostId;
+		}).catch(() => false)) await fs.rm(options.recordPath, { force: true });
+		await fs.rm(options.socketPath, { force: true });
+	}
+	return {
+		record,
+		close
+	};
+}
+//#endregion
+//#region src/server/terminal-host-entry.ts
+function requiredEnvironment(name) {
+	const value = process.env[name]?.trim();
+	if (!value) throw new Error(`${name} is required`);
+	return value;
+}
+async function main() {
+	const sessions = new TerminalHostSessionManager(requiredEnvironment("TREEPORT_TERMINAL_HOST_RUNTIME_DIR"), requiredEnvironment("TREEPORT_TERMINAL_HOST_LAUNCHER"));
+	const traceRuntime = makeHostTraceRuntime(process.env.TREEPORT_APP_VERSION ?? "unknown");
+	const trace = traceRuntime ? (name, parent, attributes, evaluate) => traceRuntime.run(name, parent, attributes, evaluate) : void 0;
+	const options = {
+		hostId: requiredEnvironment("TREEPORT_TERMINAL_HOST_ID"),
+		hostKey: requiredEnvironment("TREEPORT_TERMINAL_HOST_KEY"),
+		token: requiredEnvironment("TREEPORT_TERMINAL_HOST_TOKEN"),
+		socketPath: requiredEnvironment("TREEPORT_TERMINAL_HOST_SOCKET"),
+		recordPath: requiredEnvironment("TREEPORT_TERMINAL_HOST_RECORD"),
+		sessions,
+		onShutdown: async () => {
+			await sessions.shutdown();
+			await traceRuntime?.dispose();
+			process.exit(0);
+		}
+	};
+	if (trace) options.trace = trace;
+	const host = await startTerminalHostServer(options);
+	let stopping = false;
+	const stop = () => {
+		if (stopping) return;
+		stopping = true;
+		host.close().then(() => sessions.shutdown()).then(() => traceRuntime?.dispose()).then(() => process.exit(0), (error) => {
+			console.error("[Treeport terminal host] Shutdown failed:", error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		});
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+}
+await main();
+//#endregion
+export {};