zidane 7.2.5 → 8.0.4

package/dist/executor-Cx5-8yqi.js

@@ -0,0 +1,621 @@
+import { t as resolveStorageDirs } from "./xdg-zweed0-t.js";
+import { t as createProcessContext } from "./contexts-d7UolYot.js";
+import { Qt as MACHINE_STREAM_CHUNK_BYTES } from "./tool-formatters-IQFDrdrs.js";
+import { _ as workspacePath } from "./environment-8wsKE2Ln.js";
+import { Xt as resolveSandboxForRoots, Zt as sandboxUnreadableDirs, fn as createWorkspaceConfinement, nr as teardownWorktree, pn as isInside, tr as prepareWorktree } from "./chat-JPJJ8uu5.js";
+import { Buffer } from "node:buffer";
+import { chmodSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/ipc/machine/params.ts
+function paramsOf(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid params: expected an object.");
+	return value;
+}
+function str(params, key) {
+	const value = params[key];
+	if (typeof value !== "string") throw new Error(`Invalid params: "${key}" must be a string.`);
+	return value;
+}
+function optStr(params, key) {
+	const value = params[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new Error(`Invalid params: "${key}" must be a string.`);
+	return value;
+}
+function optNum(params, key) {
+	const value = params[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid params: "${key}" must be a number.`);
+	return value;
+}
+function num(params, key) {
+	const value = optNum(params, key);
+	if (value === void 0) throw new Error(`Invalid params: "${key}" must be a number.`);
+	return value;
+}
+function optEnv(params, key) {
+	const value = params[key];
+	if (value === void 0) return void 0;
+	if (!value || typeof value !== "object" || Array.isArray(value) || Object.values(value).some((v) => typeof v !== "string")) throw new Error(`Invalid params: "${key}" must map names to strings.`);
+	return value;
+}
+function handleRef(params) {
+	const handle = params.handle;
+	if (!handle || typeof handle.id !== "string" || typeof handle.cwd !== "string" || handle.id.length > 200) throw new Error("Invalid params: \"handle\" must be { id, cwd }.");
+	return {
+		id: handle.id,
+		cwd: handle.cwd
+	};
+}
+//#endregion
+//#region src/ipc/machine/streams.ts
+function createMachineStreams(options) {
+	const streams = /* @__PURE__ */ new Map();
+	async function pump(callId, name, source) {
+		if (!source) return;
+		for await (const chunk of source) for (let at = 0; at < chunk.byteLength; at += MACHINE_STREAM_CHUNK_BYTES) {
+			const data = Buffer.from(chunk.subarray(at, at + MACHINE_STREAM_CHUNK_BYTES)).toString("base64");
+			if (!options.send("exec.stream.data", {
+				callId,
+				stream: name,
+				data
+			})) streams.get(callId)?.kill();
+		}
+	}
+	const kill = (callId) => {
+		const stream = streams.get(callId);
+		if (!stream) return false;
+		stream.kill().catch(() => void 0);
+		return true;
+	};
+	return {
+		async start(context, handle, { callId, command, cwd, env }) {
+			if (!context.execStream) throw new Error("This machine cannot stream processes.");
+			if (streams.has(callId)) throw new Error(`A stream "${callId}" already runs.`);
+			if (streams.size >= 16) throw new Error(`This machine already runs 16 live processes.`);
+			const stream = await context.execStream(handle, command, {
+				...cwd ? { cwd } : {},
+				...env ? { env } : {}
+			});
+			streams.set(callId, stream);
+			Promise.all([
+				pump(callId, "stdout", stream.stdout),
+				pump(callId, "stderr", stream.stderr),
+				stream.exited
+			]).catch(() => void 0).then(async () => {
+				const code = await stream.exited;
+				streams.delete(callId);
+				options.send("exec.stream.exit", {
+					callId,
+					code
+				});
+			});
+			return { pid: stream.pid };
+		},
+		async write(callId, data) {
+			const stream = streams.get(callId);
+			if (!stream) throw new Error(`No live process "${callId}" on this machine.`);
+			const bytes = Buffer.from(data, "base64");
+			if (bytes.byteLength > 262144) throw new Error(`exec.stream.write: at most ${MACHINE_STREAM_CHUNK_BYTES} bytes per call.`);
+			await stream.write(bytes);
+		},
+		kill,
+		linkLost() {
+			for (const callId of streams.keys()) kill(callId);
+		},
+		async closeAll() {
+			const all = [...streams.values()];
+			streams.clear();
+			await Promise.all(all.map((stream) => stream.kill().catch(() => void 0)));
+		}
+	};
+}
+//#endregion
+//#region src/ipc/machine/task-logs.ts
+/**
+* The machine's background-task logs (`<data dir>/tasks/`): the one place in
+* its data dir the host may read, and only the logs of tasks this machine
+* started. A command run for the host can reach that folder (no sandbox, or
+* a sandbox that allows the data dir's parent), so a log path is never
+* trusted as a path: it is opened without following a symlink, must be a
+* regular file, and its real path must be the same file inside the tasks
+* dir. Otherwise `ln -sf ~/.zidane/credentials.json <log>` would make the
+* (unsandboxed) machine process read anything for the host.
+*/
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+/** `path` made (or kept) an owner-only real folder; a symlink there is refused, never followed. */
+function ownerOnlyDir(path) {
+	mkdirSync(path, {
+		recursive: true,
+		mode: 448
+	});
+	const stat = lstatSync(path);
+	if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`${path} is not a folder of this machine's task logs.`);
+	chmodSync(path, 448);
+}
+function createTaskLogs(dataDir) {
+	const dir = join(dataDir, "tasks");
+	ownerOnlyDir(dir);
+	const realDir = realpathSync.native(dir);
+	const known = /* @__PURE__ */ new Set();
+	const refused = (path) => /* @__PURE__ */ new Error(`${path} is not a task log of this machine.`);
+	/** An fd on the log at `path`, checked as the module header says; the caller closes it. */
+	const open = (path) => {
+		let fd;
+		try {
+			fd = openSync(path, constants.O_RDONLY | NO_FOLLOW);
+		} catch {
+			throw refused(path);
+		}
+		try {
+			const opened = fstatSync(fd);
+			const real = realpathSync.native(path);
+			const named = statSync(real);
+			if (!opened.isFile() || !isInside(realDir, real) || named.ino !== opened.ino || named.dev !== opened.dev) throw refused(path);
+			return fd;
+		} catch {
+			closeSync(fd);
+			throw refused(path);
+		}
+	};
+	const withLog = (path, fn) => {
+		const fd = open(path);
+		try {
+			return fn(fd);
+		} finally {
+			closeSync(fd);
+		}
+	};
+	return {
+		outputDir(handleId) {
+			const path = join(dir, Buffer.from(handleId).toString("hex").slice(0, 64));
+			ownerOnlyDir(path);
+			if (!isInside(realDir, realpathSync.native(path))) throw new Error(`${path} is not a folder of this machine's task logs.`);
+			return path;
+		},
+		add: (path) => void known.add(path),
+		has: (path) => known.has(path),
+		count: () => known.size,
+		read: (path, binary) => withLog(path, (fd) => binary ? readFileSync(fd).toString("base64") : readFileSync(fd, "utf8")),
+		size: (path) => withLog(path, (fd) => fstatSync(fd).size)
+	};
+}
+function createMachineTerminals(options) {
+	const terminals = /* @__PURE__ */ new Map();
+	const graceMs = options.graceMs ?? 3e5;
+	const entry = (terminalId) => {
+		const found = terminals.get(terminalId);
+		if (!found) throw new Error(`No terminal "${terminalId}" on this machine.`);
+		return found;
+	};
+	const remember = (e, data) => {
+		e.backlog.push(Buffer.from(data));
+		e.backlogBytes += data.byteLength;
+		e.total += data.byteLength;
+		while (e.backlogBytes > 262144 && e.backlog.length > 1) e.backlogBytes -= e.backlog.shift().byteLength;
+	};
+	const kill = async (terminalId) => {
+		const e = terminals.get(terminalId);
+		if (!e) return;
+		terminals.delete(terminalId);
+		clearTimeout(e.graceTimer);
+		await e.process.kill().catch(() => void 0);
+	};
+	return {
+		async open(context, handle, { cols, rows, cwd }) {
+			if (!context.openTerminal) throw new Error("This machine has no terminal support (it needs Bun).");
+			if (terminals.size >= 16) throw new Error(`This machine already runs 16 terminals.`);
+			const holder = {};
+			const pending = [];
+			const process = await context.openTerminal(handle, {
+				cols,
+				rows,
+				...cwd ? { cwd } : {},
+				onData: (data) => {
+					const e = holder.id ? terminals.get(holder.id) : void 0;
+					if (!e) {
+						pending.push(data);
+						return;
+					}
+					remember(e, data);
+					options.send("terminal.data", {
+						terminalId: holder.id,
+						data: Buffer.from(data).toString("base64")
+					});
+				}
+			});
+			holder.id = process.id;
+			const e = {
+				process,
+				backlog: [],
+				backlogBytes: 0,
+				total: 0
+			};
+			terminals.set(process.id, e);
+			for (const data of pending) remember(e, data);
+			process.exited.then((code) => {
+				if (terminals.get(process.id) !== e) return;
+				terminals.delete(process.id);
+				clearTimeout(e.graceTimer);
+				options.send("terminal.exit", {
+					terminalId: process.id,
+					code
+				});
+			});
+			return process.id;
+		},
+		attach(terminalId) {
+			const e = terminals.get(terminalId);
+			if (!e) return {
+				attached: false,
+				backlog: "",
+				total: 0
+			};
+			clearTimeout(e.graceTimer);
+			e.graceTimer = void 0;
+			return {
+				attached: true,
+				backlog: Buffer.concat(e.backlog).toString("base64"),
+				total: e.total
+			};
+		},
+		write: (terminalId, data) => entry(terminalId).process.write(Buffer.from(data, "base64")),
+		resize: (terminalId, cols, rows) => entry(terminalId).process.resize(cols, rows),
+		kill,
+		linkLost() {
+			for (const [id, e] of terminals) {
+				clearTimeout(e.graceTimer);
+				e.graceTimer = setTimeout(() => void kill(id), graceMs);
+				e.graceTimer.unref?.();
+			}
+		},
+		async closeAll() {
+			await Promise.all([...terminals.keys()].map(kill));
+		}
+	};
+}
+const MACHINE_TASK_OUTPUT_BYTES = 8388608;
+const MAX_PENDING_EXITS = 256;
+const GLOB_CHARS = /[*?[\]{}]/;
+/**
+* What file operations never reach, whatever the roots (`docs/MACHINES.md` §
+* Security model): zidane's own folders as this process resolves them (data,
+* config, state, cache: credentials, tokens, extensions, plugins, skills,
+* mcps.json, SYSTEM.md, the machine's data, sync files), the default
+* `~/.zidane`, the given data dir (a server's `--data-dir`), and the
+* credential folders the sandbox hides (`~/.ssh`, `~/.aws`, …).
+*/
+function machinePrivateDirs(zidaneDataDir) {
+	const storage = resolveStorageDirs();
+	return [.../* @__PURE__ */ new Set([
+		...zidaneDataDir ? [zidaneDataDir] : [],
+		storage.dataDir,
+		storage.configDir,
+		storage.stateDir,
+		storage.cacheDir,
+		join(homedir(), ".zidane"),
+		...sandboxUnreadableDirs(zidaneDataDir)
+	])];
+}
+/** The static directory of a glob (`/a/b/**\/*.ts` → `/a/b`). */
+function globBase(path) {
+	const segments = path.split("/");
+	const index = segments.findIndex((s) => GLOB_CHARS.test(s));
+	return index < 0 ? path : segments.slice(0, index).join("/") || "/";
+}
+/**
+* A folder a user offers to share (`zidane machine share --root`, a share
+* link): its real path must exist and not be, or be inside, a private
+* folder (a root there would lend what {@link machinePrivateDirs} keeps out).
+* Returns the real path.
+*/
+function shareableRoot(root, zidaneDataDir) {
+	let real;
+	try {
+		real = realpathSync.native(root);
+	} catch {
+		throw new Error(`${root} does not exist.`);
+	}
+	const hidden = machinePrivateDirs(zidaneDataDir).map(realPathOr).find((dir) => isInside(dir, real));
+	if (hidden) throw new Error(`${root} is inside ${hidden} (zidane's own data or credentials): share a folder outside it.`);
+	return real;
+}
+function realPathOr(path) {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return path;
+	}
+}
+function machineConfinement(roots, dataDir, privateDirs = []) {
+	const worktrees = join(dataDir, "worktrees");
+	mkdirSync(worktrees, { recursive: true });
+	return createWorkspaceConfinement([...roots.map((root) => root.path), worktrees], {
+		dataDir,
+		privateDirs,
+		names: {
+			roots: "the machine's roots",
+			dataDir: "the machine's data dir, which the host can't reach"
+		}
+	});
+}
+/**
+* A listing's entries whose real path is reachable: a traversal can follow a
+* symlinked folder out of the roots, or walk into a private one, from a base
+* that passed the check.
+*/
+function reachableEntries(confinement, base, entries) {
+	return entries.filter((entry) => {
+		const path = typeof entry === "string" ? entry : entry.path;
+		if (typeof path !== "string") return false;
+		try {
+			confinement.checkPath(isAbsolute(path) ? path : resolve(base, path));
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}
+/** `fs.list`: a path or glob under the handle's cwd, no `..` in a pattern, only reachable entries back. */
+async function listReachable(context, confinement, handle, params) {
+	const pattern = str(params, "path");
+	if (GLOB_CHARS.test(pattern) && pattern.split(/[/\\]/).includes("..")) throw new Error(`"${pattern}": a pattern can't climb with "..".`);
+	const path = workspacePath(handle.cwd, pattern);
+	confinement.checkPath(globBase(path));
+	const raw = params.options && typeof params.options === "object" ? params.options : {};
+	const listOptions = {
+		...typeof raw.glob === "boolean" ? { glob: raw.glob } : {},
+		...typeof raw.limit === "number" ? { limit: raw.limit } : {},
+		...typeof raw.metadata === "boolean" ? { metadata: raw.metadata } : {},
+		...typeof raw.gitignore === "boolean" ? { gitignore: raw.gitignore } : {}
+	};
+	return reachableEntries(confinement, globBase(path), await context.listFiles(handle, path, listOptions));
+}
+/** One process context for every handle, under the machine user's own sandbox when it is on. */
+function sandboxedContext(options, confinement) {
+	const sandbox = resolveSandboxForRoots(options.sandbox ?? { sandbox: false }, confinement.roots, { ...options.credentialsDataDir ? { dataDir: options.credentialsDataDir } : {} });
+	return {
+		sandbox,
+		context: createProcessContext({
+			cwd: confinement.roots[0],
+			...sandbox.isolation ? { isolation: sandbox.isolation } : {}
+		})
+	};
+}
+function createMachineExecutor(options) {
+	const confinement = machineConfinement(options.roots, options.dataDir, machinePrivateDirs(options.credentialsDataDir));
+	const { sandbox, context } = sandboxedContext(options, confinement);
+	const handles = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
+	const taskLogs = createTaskLogs(options.dataDir);
+	const pendingExits = [];
+	const terminals = createMachineTerminals({
+		send: options.notify,
+		...options.terminalGraceMs !== void 0 ? { graceMs: options.terminalGraceMs } : {}
+	});
+	const streams = createMachineStreams({ send: options.notify });
+	/** A handle's cwd, checked on every call (not only at spawn): the host names it each time. */
+	async function handleFor(params) {
+		const ref = handleRef(params);
+		const cwd = confinement.resolveFolder(ref.cwd);
+		const existing = handles.get(ref.id);
+		if (existing && existing.cwd === cwd) return existing;
+		const handle = await context.spawn({ cwd });
+		handles.set(ref.id, handle);
+		if (existing) await context.destroy(existing).catch(() => void 0);
+		return handle;
+	}
+	/** `path` resolved like the context resolves it, then confined. */
+	function checked(handle, path) {
+		const absolute = workspacePath(handle.cwd, path);
+		confinement.checkPath(absolute);
+		return absolute;
+	}
+	/** A log of a task this machine started, by its path (never through the context: see `./task-logs.ts`). */
+	const taskLog = (handle, path) => {
+		const absolute = workspacePath(handle.cwd, path);
+		return taskLogs.has(absolute) ? absolute : void 0;
+	};
+	const cwdOption = (handle, params) => {
+		const cwd = optStr(params, "cwd");
+		return cwd === void 0 ? {} : { cwd: confinement.resolveFolder(workspacePath(handle.cwd, cwd)) };
+	};
+	const sendExit = (exit) => {
+		if (options.notify("task.exit", exit)) return;
+		pendingExits.push(exit);
+		if (pendingExits.length > MAX_PENDING_EXITS) pendingExits.shift();
+	};
+	const methods = {
+		"machine.ping": async () => ({ ok: true }),
+		"exec.spawn": async (params) => {
+			const handle = await handleFor(params);
+			return {
+				id: handleRef(params).id,
+				cwd: handle.cwd
+			};
+		},
+		"exec.run": async (params) => {
+			const handle = await handleFor(params);
+			const callId = str(params, "callId");
+			if (calls.has(callId)) throw new Error(`A call "${callId}" is already running.`);
+			const controller = new AbortController();
+			calls.set(callId, controller);
+			try {
+				const env = optEnv(params, "env");
+				const timeout = optNum(params, "timeout");
+				return await context.exec(handle, str(params, "command"), {
+					...cwdOption(handle, params),
+					...env ? { env } : {},
+					...timeout !== void 0 ? { timeout } : {},
+					signal: controller.signal
+				});
+			} finally {
+				calls.delete(callId);
+			}
+		},
+		"exec.cancel": async (params) => {
+			const callId = str(params, "callId");
+			const controller = calls.get(callId);
+			controller?.abort();
+			return { cancelled: controller !== void 0 || streams.kill(callId) };
+		},
+		"exec.stream": async (params) => {
+			const handle = await handleFor(params);
+			const env = optEnv(params, "env");
+			return streams.start(context, handle, {
+				callId: str(params, "callId"),
+				command: str(params, "command"),
+				...cwdOption(handle, params),
+				...env ? { env } : {}
+			});
+		},
+		"exec.stream.write": async (params) => {
+			await streams.write(str(params, "callId"), str(params, "data"));
+			return { ok: true };
+		},
+		"exec.destroy": async (params) => {
+			const ref = handleRef(params);
+			const handle = handles.get(ref.id);
+			handles.delete(ref.id);
+			if (handle) await context.destroy(handle);
+			return { ok: true };
+		},
+		"fs.read": async (params) => {
+			const handle = await handleFor(params);
+			const log = taskLog(handle, str(params, "path"));
+			if (log) return { content: taskLogs.read(log, params.binary === true) };
+			const path = checked(handle, str(params, "path"));
+			if (params.binary === true) return { content: Buffer.from(await context.readFileBinary(handle, path)).toString("base64") };
+			return { content: await context.readFile(handle, path) };
+		},
+		"fs.write": async (params) => {
+			const handle = await handleFor(params);
+			await context.writeFile(handle, checked(handle, str(params, "path")), Buffer.from(str(params, "content"), "base64"));
+			return { ok: true };
+		},
+		"fs.list": async (params) => ({ entries: await listReachable(context, confinement, await handleFor(params), params) }),
+		"fs.size": async (params) => {
+			const handle = await handleFor(params);
+			const log = taskLog(handle, str(params, "path"));
+			return { size: log ? taskLogs.size(log) : await context.fileSize(handle, checked(handle, str(params, "path"))) };
+		},
+		"bg.start": async (params) => {
+			const handle = await handleFor(params);
+			const running = (await context.listBackground(handle)).filter((t) => t.status === "running").length;
+			if (taskLogs.count() >= 256 || running >= 64) throw new Error(`This machine already runs 64 background tasks.`);
+			const env = optEnv(params, "env");
+			const cap = optNum(params, "maxOutputBytes");
+			const task = await context.execBackground(handle, str(params, "command"), {
+				...cwdOption(handle, params),
+				...env ? { env } : {},
+				outputDir: taskLogs.outputDir(handleRef(params).id),
+				maxOutputBytes: Math.min(cap && cap > 0 ? cap : MACHINE_TASK_OUTPUT_BYTES, MACHINE_TASK_OUTPUT_BYTES),
+				onExit: (info) => sendExit({
+					taskId: info.taskId,
+					exit: { ...info }
+				})
+			});
+			taskLogs.add(task.outputPath);
+			return {
+				taskId: task.taskId,
+				pid: task.pid,
+				outputPath: task.outputPath
+			};
+		},
+		"bg.list": async (params) => ({ tasks: await context.listBackground(await handleFor(params)) }),
+		"bg.kill": async (params) => ({ exit: await context.killBackground(await handleFor(params), str(params, "taskId")) }),
+		"bg.wait": async (params) => {
+			const timeoutMs = optNum(params, "timeoutMs");
+			return { exit: await context.waitBackground(await handleFor(params), str(params, "taskId"), timeoutMs !== void 0 ? { timeoutMs } : {}) };
+		},
+		"terminal.open": async (params) => {
+			const handle = await handleFor(params);
+			return { terminalId: await terminals.open(context, handle, {
+				cols: num(params, "cols"),
+				rows: num(params, "rows"),
+				...cwdOption(handle, params)
+			}) };
+		},
+		"terminal.attach": async (params) => terminals.attach(str(params, "terminalId")),
+		"terminal.write": async (params) => {
+			terminals.write(str(params, "terminalId"), str(params, "data"));
+			return { ok: true };
+		},
+		"terminal.resize": async (params) => {
+			terminals.resize(str(params, "terminalId"), num(params, "cols"), num(params, "rows"));
+			return { ok: true };
+		},
+		"terminal.kill": async (params) => {
+			await terminals.kill(str(params, "terminalId"));
+			return { ok: true };
+		},
+		"terminal.detach": async () => ({ ok: true }),
+		"env.checkFolder": async (params) => ({ cwd: confinement.resolveFolder(str(params, "cwd")) }),
+		"env.prepareWorktree": async (params) => {
+			const cwd = confinement.resolveFolder(str(params, "cwd"));
+			const config = params.config && typeof params.config === "object" ? params.config : {};
+			const base = optStr(params, "base");
+			const prepared = await prepareWorktree({
+				cwd,
+				environment: {
+					kind: "worktree",
+					state: "provisioning",
+					branch: str(params, "branch"),
+					...base ? { base } : {}
+				},
+				config
+			}, options.dataDir);
+			const ref = prepared.environment?.ref;
+			confinement.resolveFolder(ref.path);
+			return {
+				cwd: prepared.cwd ?? ref.path,
+				branch: prepared.environment?.branch,
+				base: prepared.environment?.base,
+				ref
+			};
+		},
+		"env.teardownWorktree": async (params) => {
+			const ref = params.ref ?? {};
+			if (typeof ref.path !== "string" || typeof ref.repoRoot !== "string") throw new Error("Invalid params: \"ref\" must be { path, repoRoot }.");
+			confinement.checkPath(ref.path);
+			confinement.resolveFolder(ref.repoRoot);
+			const config = params.config && typeof params.config === "object" ? params.config : {};
+			return teardownWorktree({
+				path: ref.path,
+				repoRoot: ref.repoRoot
+			}, optStr(params, "branch"), config);
+		}
+	};
+	return {
+		async handle(method, raw) {
+			if (!Object.hasOwn(methods, method)) throw new Error(`Unknown machine method "${method}".`);
+			return methods[method](paramsOf(raw));
+		},
+		linkUp() {
+			while (pendingExits.length > 0) {
+				if (!options.notify("task.exit", pendingExits[0])) return;
+				pendingExits.shift();
+			}
+		},
+		sandbox: {
+			on: sandbox.isolation !== void 0,
+			...sandbox.warning ? { warning: sandbox.warning } : {}
+		},
+		linkLost: () => {
+			terminals.linkLost();
+			streams.linkLost();
+		},
+		async close() {
+			for (const controller of calls.values()) controller.abort();
+			await streams.closeAll();
+			await terminals.closeAll();
+			await Promise.all([...handles.values()].map((handle) => context.destroy(handle).catch(() => void 0)));
+			handles.clear();
+		}
+	};
+}
+//#endregion
+export { createMachineExecutor, shareableRoot };
+
+//# sourceMappingURL=executor-Cx5-8yqi.js.map