acrylblends 0.8.1 → 0.9.0

package/lib/cordis/door.js

@@ -0,0 +1,757 @@
+import { t as Acryl } from "../app-BM0rTCp7.js";
+import { n as clientModules } from "../client-modules-CLvWOjbd.js";
+import { MAX_SNAPSHOT_NODES, MAX_WAIT_MS, UiControlError, parseUiRequest } from "../door/protocol.js";
+import { a as INVALID_JSON, c as operatorOnly, d as AuditLog, f as auditPath, i as DOOR_PREFIX, l as privateApi, o as error, p as UiChannel, r as pageChannelRoutes, s as jsonBody, t as renderSnapshot, u as readJson } from "../snapshot-text-D3NspDyT.js";
+import "../src-CwABFr6r.js";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-door/src/host/verbs.ts
+/**
+* The one verb list (spec 049 slice 13). Every face of the door reads it: the operator client (`acryl <verb>`, its `verbs` and `brief`),
+* MCP (`tools/list`) and the built-in chat (the `tools` registry). A verb added here is in all three, or the comparison test fails.
+*/
+/** Every verb, in the order `brief` lists them. */
+const VERBS = [
+	"brief",
+	"look",
+	"act",
+	"plugin-list",
+	"plugin-add",
+	"plugin-remove",
+	"plugin-reload",
+	"tool-list",
+	"tool-call"
+];
+const none = {
+	type: "object",
+	properties: {},
+	additionalProperties: false
+};
+const VERB_SPECS = {
+	"brief": {
+		usage: "brief: this summary",
+		description: "What this app is, which files to read first, whether its page is open, and the verbs.",
+		arguments: none
+	},
+	"look": {
+		usage: "look [--cursor <n>] [--max-nodes <n>]: the page as text, with refs",
+		description: "The open page as text: its roles, names, values and visible text, each with a ref to act on. A long page comes in parts (cursor).",
+		arguments: {
+			type: "object",
+			properties: {
+				cursor: {
+					type: "integer",
+					minimum: 0,
+					description: "where the previous part ended"
+				},
+				maxNodes: {
+					type: "integer",
+					minimum: 1,
+					maximum: MAX_SNAPSHOT_NODES
+				}
+			},
+			additionalProperties: false
+		}
+	},
+	"act": {
+		usage: "act click|type|select|press|scroll|wait ...: do one thing on the page (refs from the latest look)",
+		description: "Do one thing on the page: click, type, select, press a key, scroll, or wait for text or a control. Look again before the next act.",
+		arguments: {
+			type: "object",
+			properties: {
+				op: {
+					type: "string",
+					enum: [
+						"click",
+						"type",
+						"select",
+						"press",
+						"scroll",
+						"wait"
+					]
+				},
+				ref: {
+					type: "string",
+					description: "a ref from the latest look, e.g. 3.12"
+				},
+				text: {
+					type: "string",
+					description: "type: what to type; wait: the text to wait for"
+				},
+				submit: {
+					type: "boolean",
+					description: "type: press Enter after"
+				},
+				clear: {
+					type: "boolean",
+					description: "type: false keeps what the field holds"
+				},
+				option: {
+					type: "string",
+					description: "select: the option to choose"
+				},
+				key: {
+					type: "string",
+					description: "press: a character or Enter, Escape, Tab, ArrowDown, ..."
+				},
+				direction: {
+					type: "string",
+					enum: [
+						"up",
+						"down",
+						"left",
+						"right"
+					]
+				},
+				amount: {
+					type: "number",
+					minimum: 1,
+					maximum: 1e4,
+					description: "scroll: pixels"
+				},
+				role: {
+					type: "string",
+					description: "wait: the role to wait for"
+				},
+				name: {
+					type: "string",
+					description: "wait: its name"
+				},
+				gone: {
+					type: "boolean",
+					description: "wait: until it is gone instead"
+				},
+				timeoutMs: {
+					type: "integer",
+					minimum: 0,
+					maximum: MAX_WAIT_MS
+				}
+			},
+			required: ["op"],
+			additionalProperties: false
+		}
+	},
+	"plugin-list": {
+		usage: "plugin list: the plugins installed while the app runs",
+		description: "The plugins installed into the running app.",
+		arguments: none
+	},
+	"plugin-add": {
+		usage: "plugin add <folder>: check, install and start a plugin folder, live",
+		description: "Check, install and start a plugin folder inside the app, without a restart.",
+		arguments: {
+			type: "object",
+			properties: { folder: {
+				type: "string",
+				description: "a folder inside the app, e.g. plugins/pomodoro"
+			} },
+			required: ["folder"],
+			additionalProperties: false
+		}
+	},
+	"plugin-remove": {
+		usage: "plugin remove <name>: stop and remove an installed plugin",
+		description: "Stop and remove an installed plugin.",
+		arguments: {
+			type: "object",
+			properties: { name: { type: "string" } },
+			required: ["name"],
+			additionalProperties: false
+		}
+	},
+	"plugin-reload": {
+		usage: "plugin reload: bring every installed plugin in line with its folder",
+		description: "Bring every installed plugin in line with its folder (after editing one).",
+		arguments: none
+	},
+	"tool-list": {
+		usage: "tool list: the app tools the door offers",
+		description: "The app's own tools that the door offers.",
+		arguments: none
+	},
+	"tool-call": {
+		usage: "tool call --tool <name> [--args <json>]: run one of them",
+		description: "Run one of the app tools that tool-list names.",
+		arguments: {
+			type: "object",
+			properties: {
+				tool: { type: "string" },
+				args: { description: "the tool's input" }
+			},
+			required: ["tool"],
+			additionalProperties: false
+		}
+	}
+};
+/** A verb's name in the `tools` registry the built-in chat reads: prefixed, so it never meets an app tool's name. */
+const chatToolName = (verb) => `door_${verb.replaceAll("-", "_")}`;
+//#endregion
+//#region ../../plugins/acryl-door/src/host/door.ts
+/**
+* The door's verbs, one implementation for every face: `brief`, `look`, `act`, `plugin list|add|remove|reload` and `tool list|call`
+* (`verbs.ts` lists them; the operator client, MCP and the built-in chat all call these). Each verb takes plain JSON arguments,
+* returns a typed value and a text rendering, and fails with a {@link DoorError} or a {@link UiControlError} carrying a code.
+*/
+var DoorError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "DoorError";
+	}
+};
+/** The files an agent should read first, when the app has them. */
+const SELF_KNOWLEDGE = [
+	"AGENTS.md",
+	"CLAUDE.md",
+	".agents/skills",
+	".claude/skills",
+	"docs",
+	"plugins"
+];
+var Door = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Run one verb. @throws DoorError or UiControlError. */
+	async run(verb, args, signal) {
+		const input = typeof args === "object" && args !== null && !Array.isArray(args) ? args : {};
+		switch (verb) {
+			case "brief": return this.brief();
+			case "look": {
+				const snapshot = await this.look(input, signal);
+				return {
+					value: snapshot,
+					text: renderSnapshot(snapshot, (cursor) => `run look --cursor ${String(cursor)}`)
+				};
+			}
+			case "act": {
+				const result = await this.act(input, signal);
+				return {
+					value: result,
+					text: `done${result.target === void 0 ? "" : `: ${result.target.role} "${result.target.name}"`}${result.detail === void 0 ? "" : ` (${result.detail})`}; look again before the next act`
+				};
+			}
+			case "plugin-list": return this.plugin((extensions) => extensions.list());
+			case "plugin-add": return this.plugin((extensions) => extensions.install(this.insideApp(input.folder)));
+			case "plugin-remove": {
+				const name = input.name;
+				if (typeof name !== "string" || name === "") throw new DoorError("invalid", "plugin remove needs a plugin name");
+				return this.plugin((extensions) => extensions.remove(name));
+			}
+			case "plugin-reload": return this.plugin((extensions) => extensions.reload());
+			case "tool-list": {
+				const offered = this.offeredTools();
+				return {
+					value: offered,
+					text: offered.length === 0 ? "no app tools are offered through the door (tools.expose is empty)" : offered.map((tool) => `${tool.name}: ${tool.description}`).join("\n")
+				};
+			}
+			case "tool-call": return this.callTool(input);
+			default: throw new DoorError("unknown-verb", `unknown verb ${JSON.stringify(verb)}; the verbs are ${VERBS.join(", ")}`);
+		}
+	}
+	brief() {
+		const { name, root } = this.deps.app;
+		const read = SELF_KNOWLEDGE.filter((path) => existsSync(resolve(root, path)));
+		const value = {
+			app: name,
+			root,
+			read,
+			page: this.deps.channel.connected ? "open" : "not open",
+			plugins: this.deps.extensions() === void 0 ? "unavailable" : "available",
+			verbs: VERBS.map((verb) => VERB_SPECS[verb].usage)
+		};
+		return {
+			value,
+			text: [
+				`App ${name} in ${root}.`,
+				read.length === 0 ? "No AGENTS.md or skill in the folder." : `Read first: ${read.join(", ")}.`,
+				`Page: ${value.page}${value.page === "not open" ? " (open the app in a browser to look and act)" : ""}.`,
+				`Live plugins: ${value.plugins}.`,
+				"Verbs:",
+				...value.verbs.map((line) => `  ${line}`)
+			].join("\n")
+		};
+	}
+	look(input, signal) {
+		const request = this.parse({
+			...input,
+			op: "snapshot"
+		});
+		return this.callPage("look", request, signal);
+	}
+	act(input, signal) {
+		if (input.op === "snapshot") throw new DoorError("invalid", "use look to see the page");
+		return this.callPage(`act ${String(input.op)}`, this.parse(input), signal);
+	}
+	parse(input) {
+		try {
+			return parseUiRequest(input);
+		} catch (cause) {
+			throw new DoorError("invalid", cause instanceof Error ? cause.message : "invalid request");
+		}
+	}
+	/** Run one call on the page and record it. The audit holds which control was touched and how it ended, never what was typed. */
+	async callPage(verb, request, signal) {
+		const approval = "token";
+		try {
+			const value = await this.deps.channel.call(request, {
+				signal,
+				...request.op === "wait" ? { timeoutMs: (request.timeoutMs ?? 3e3) + 5e3 } : {}
+			});
+			const target = "target" in value ? value.target : void 0;
+			this.deps.audit.record({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				tool: verb,
+				...target === void 0 ? {} : { target },
+				outcome: "ok",
+				approval
+			});
+			return value;
+		} catch (cause) {
+			const code = cause instanceof UiControlError ? cause.code : "failed";
+			const refused = cause instanceof UiControlError && [
+				"protected",
+				"sensitive",
+				"killed",
+				"invalid",
+				"stale-ref",
+				"unknown-ref",
+				"not-actionable"
+			].includes(cause.code);
+			this.deps.audit.record({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				tool: verb,
+				outcome: refused ? "refused" : "failed",
+				detail: code,
+				approval
+			});
+			throw cause;
+		}
+	}
+	async plugin(run) {
+		const extensions = this.deps.extensions();
+		if (extensions === void 0) throw new DoorError("unavailable", "this app has no extensions plugin, so plugins cannot be installed while it runs");
+		const value = await run(extensions);
+		return {
+			value,
+			text: JSON.stringify(value, null, 2)
+		};
+	}
+	/** A folder named by an agent, resolved from the app folder; it must be inside the app. */
+	insideApp(folder) {
+		if (typeof folder !== "string" || folder === "") throw new DoorError("invalid", "plugin add needs a folder, e.g. plugins/pomodoro");
+		const root = this.deps.app.root;
+		const full = resolve(root, folder);
+		const path = relative(root, full);
+		if (path === "" || path.startsWith("..") || isAbsolute(path)) throw new DoorError("outside-app", `${folder} is not a folder inside the app (${root})`);
+		return full;
+	}
+	offeredTools() {
+		const tools = this.deps.tools();
+		if (tools === void 0) return [];
+		const allowed = new Set(this.deps.expose);
+		return tools.list().filter((tool) => allowed.has(tool.name)).map(({ name, description }) => ({
+			name,
+			description
+		}));
+	}
+	async callTool(input) {
+		const name = input.tool;
+		if (typeof name !== "string" || name === "") throw new DoorError("invalid", "tool call needs --tool <name>");
+		if (!this.deps.expose.includes(name)) throw new DoorError("not-exposed", `${name} is not offered through the door`);
+		const tools = this.deps.tools();
+		if (tools === void 0 || !tools.list().some((tool) => tool.name === name)) throw new DoorError("unavailable", `${name} is not available right now`);
+		let value;
+		try {
+			value = await tools.call(name, input.args ?? {});
+		} catch (cause) {
+			throw new DoorError("failed", cause instanceof Error ? cause.message : String(cause));
+		}
+		return {
+			value,
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		};
+	}
+};
+//#endregion
+//#region ../../plugins/acryl-door/src/host/chat-tools.ts
+/**
+* The door in the built-in chat: each verb registered in the app's `tools` registry (the one the chat's agent reads), as
+* `door_<verb>`. A tool answers the verb's text, what an agent reads in a terminal; a failed verb throws with its code, as the operator
+* client prints it.
+*/
+/** Register every verb. @returns the function that removes them all; it also aborts the calls still running. */
+function registerChatTools(tools, door) {
+	const running = new AbortController();
+	const removers = [];
+	const removeAll = () => {
+		running.abort();
+		for (const remove of removers.splice(0).reverse()) remove();
+	};
+	try {
+		for (const verb of VERBS) removers.push(tools.register(chatToolName(verb), {
+			description: VERB_SPECS[verb].description,
+			run: async (input) => {
+				try {
+					return (await door.run(verb, input ?? {}, running.signal)).text;
+				} catch (cause) {
+					if (cause instanceof DoorError || cause instanceof UiControlError) throw new Error(`${cause.code}: ${cause.message}`, { cause });
+					throw cause;
+				}
+			}
+		}));
+	} catch (cause) {
+		removeAll();
+		throw cause;
+	}
+	return removeAll;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/host/door-file.ts
+/**
+* The door's connection file, `<app>/.acryl/door.json`: where the running app listens and this run's secret, for the operator client in
+* the same folder. The secret is never on a command line or in an environment variable another process can read.
+*
+* Protection: on macOS and Linux the folder is `0700` and the file `0600`, so only the OS user who started the app can read it. On
+* Windows file modes mean nothing; the file is protected by where it lives, the app folder in the user's profile, whose ACL gives access
+* to that user, SYSTEM and Administrators only. The door does not widen it. The folder also carries its own `.gitignore` of `*`, so
+* `git add -A` never stages the secret even in an app whose `.gitignore` lacks the `.acryl/` line.
+*/
+/** The folder of the door's state below the app folder. */
+const STATE_DIR = ".acryl";
+const DOOR_FILE = "door.json";
+function stateDir(appRoot) {
+	return join(appRoot, STATE_DIR);
+}
+function doorFilePath(appRoot) {
+	return join(stateDir(appRoot), DOOR_FILE);
+}
+/** A fresh secret for this run; a restart rotates it. */
+function newSecret() {
+	return randomBytes(24).toString("hex");
+}
+/** The state folder, private, with its own `.gitignore`. */
+function ensureStateDir(appRoot) {
+	const dir = stateDir(appRoot);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	if (process.platform !== "win32") chmodSync(dir, 448);
+	const ignore = join(dir, ".gitignore");
+	if (!existsSync(ignore)) writeFileSync(ignore, "# The door's state: this run's secret and the audit. Never commit it.\n*\n");
+	return dir;
+}
+/** The connection file as written, or undefined when there is none or it does not parse. */
+function readDoorFile(appRoot) {
+	try {
+		const value = JSON.parse(readFileSync(doorFilePath(appRoot), "utf8"));
+		if (value.version === 1 && typeof value.url === "string" && typeof value.secret === "string" && typeof value.pid === "number") return value;
+	} catch {}
+}
+/** True while the process is alive (a process of another user still counts: `EPERM`). */
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (cause) {
+		return cause.code === "EPERM";
+	}
+}
+/**
+* Write this run's connection file, replacing a stale one.
+* @throws when another live process already serves this folder's door: two apps from one folder would race for one file.
+*/
+function writeDoorFile(appRoot, url, secret) {
+	const dir = ensureStateDir(appRoot);
+	const existing = readDoorFile(appRoot);
+	if (existing !== void 0 && existing.pid !== process.pid && alive(existing.pid)) throw new Error(`acryl-door: another process (pid ${String(existing.pid)}) serves the door of ${appRoot}; stop it first`);
+	const file = doorFilePath(appRoot);
+	const temporary = join(dir, `${DOOR_FILE}.${String(process.pid)}.tmp`);
+	const content = {
+		version: 1,
+		url,
+		secret,
+		pid: process.pid
+	};
+	writeFileSync(temporary, `${JSON.stringify(content)}\n`, { mode: 384 });
+	if (process.platform !== "win32") chmodSync(temporary, 384);
+	renameSync(temporary, file);
+	return file;
+}
+/** Remove the connection file, only when it is this run's: a newer run's file is left alone. */
+function removeDoorFile(appRoot, secret) {
+	if (readDoorFile(appRoot)?.secret === secret) rmSync(doorFilePath(appRoot), { force: true });
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/host/mcp-routes.ts
+/**
+* The door over MCP: `POST <prefix>/mcp`, streamable HTTP in its request/response form (one JSON-RPC message or a batch in, its JSON
+* answer out, 202 for notifications only; no event stream is offered). Each verb is one tool, named as the verb, with the arguments the
+* operator client sends. The same guard as the operator's routes: loopback, this run's secret.
+*/
+const SUPPORTED_PROTOCOLS = [
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
+const SERVER_INFO = {
+	name: "acryl-door",
+	version: "1"
+};
+function isRequest(value) {
+	return typeof value === "object" && value !== null && value.jsonrpc === "2.0" && typeof value.method === "string";
+}
+const rpcError = (id, code, message) => ({
+	jsonrpc: "2.0",
+	id: id ?? null,
+	error: {
+		code,
+		message
+	}
+});
+const result = (id, value) => ({
+	jsonrpc: "2.0",
+	id: id ?? null,
+	result: value
+});
+/** The verbs as MCP tools. */
+function mcpTools() {
+	return VERBS.map((verb) => ({
+		name: verb,
+		description: VERB_SPECS[verb].description,
+		inputSchema: VERB_SPECS[verb].arguments
+	}));
+}
+const isVerb = (name) => typeof name === "string" && VERBS.includes(name);
+/** One JSON-RPC message; `undefined` for a notification (no answer owed). */
+async function answer(message, door, signal) {
+	const isNotification = message.id === void 0;
+	switch (message.method) {
+		case "initialize": {
+			const asked = message.params?.protocolVersion;
+			const protocolVersion = SUPPORTED_PROTOCOLS.includes(asked) ? asked : SUPPORTED_PROTOCOLS[0];
+			return result(message.id, {
+				protocolVersion,
+				capabilities: { tools: { listChanged: false } },
+				serverInfo: SERVER_INFO
+			});
+		}
+		case "ping": return isNotification ? void 0 : result(message.id, {});
+		case "tools/list": return result(message.id, { tools: mcpTools() });
+		case "tools/call": {
+			const params = typeof message.params === "object" && message.params !== null ? message.params : {};
+			if (!isVerb(params.name)) return rpcError(message.id, -32602, `unknown tool ${JSON.stringify(params.name)}; the tools are ${VERBS.join(", ")}`);
+			try {
+				const verbAnswer = await door.run(params.name, params.arguments ?? {}, signal);
+				return result(message.id, {
+					content: [{
+						type: "text",
+						text: verbAnswer.text
+					}],
+					structuredContent: { value: verbAnswer.value },
+					isError: false
+				});
+			} catch (cause) {
+				if (cause instanceof DoorError || cause instanceof UiControlError) return result(message.id, {
+					content: [{
+						type: "text",
+						text: `${cause.code}: ${cause.message}`
+					}],
+					isError: true
+				});
+				throw cause;
+			}
+		}
+		default: return isNotification ? void 0 : rpcError(message.id, -32601, `method not found: ${message.method}`);
+	}
+}
+function mcpRoutes(prefix, secret, door, reportError) {
+	return new Acryl().post(`${prefix}/mcp`, operatorOnly(secret), jsonBody, async (c) => {
+		const body = await readJson(c);
+		if (body === INVALID_JSON) return c.json(rpcError(null, -32700, "parse error"), 400);
+		try {
+			const messages = Array.isArray(body) ? body : [body];
+			const answers = [];
+			for (const message of messages) {
+				if (!isRequest(message)) {
+					answers.push(rpcError(null, -32600, "invalid request"));
+					continue;
+				}
+				const response = await answer(message, door, c.req.raw.signal);
+				if (response !== void 0) answers.push(response);
+			}
+			if (answers.length === 0) return c.body(null, 202);
+			return c.json(Array.isArray(body) ? answers : answers[0]);
+		} catch (cause) {
+			reportError("answer an MCP request", cause);
+			return c.json(rpcError(null, -32603, "internal error"), 500);
+		}
+	});
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/host/operator-routes.ts
+/**
+* The operator's routes: an agent's shell on this machine, through `.acryl/bin/acryl`. Loopback only, with this run's secret.
+*
+* `POST <prefix>/call` takes `{ verb, args }` and answers {@link CallResponse}; `GET <prefix>/verbs` lists the verbs. A caller that goes
+* away aborts its call through the request's signal.
+*/
+function operatorRoutes(prefix, secret, door, reportError) {
+	return new Acryl().get(`${prefix}/verbs`, operatorOnly(secret), (c) => c.json({ verbs: VERBS })).post(`${prefix}/call`, operatorOnly(secret), jsonBody, async (c) => {
+		const body = await readJson(c);
+		if (body === INVALID_JSON || typeof body !== "object" || body === null || typeof body.verb !== "string") return c.json({
+			ok: false,
+			code: "invalid",
+			message: "the body is { verb, args }"
+		}, 400);
+		const { verb, args } = body;
+		try {
+			const answer = await door.run(verb, args, c.req.raw.signal);
+			return c.json({
+				ok: true,
+				value: answer.value,
+				text: answer.text
+			});
+		} catch (cause) {
+			if (cause instanceof UiControlError || cause instanceof DoorError) return c.json({
+				ok: false,
+				code: cause.code,
+				message: cause.message
+			}, cause.code === "invalid" || cause.code === "unknown-verb" ? 400 : 200);
+			reportError(`run the door verb ${verb}`, cause);
+			return c.json(error("the verb could not be run"), 500);
+		}
+	});
+}
+/** A word for `sh`: single-quoted, with each `'` closed, escaped and reopened. */
+function shWord(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+/** A word for `cmd.exe`: double-quoted; `%` doubled so a batch file does not expand it. A path cannot hold `"`. */
+function cmdWord(value) {
+	return `"${value.replaceAll("%", "%%")}"`;
+}
+function posixShim(root, target) {
+	const words = [
+		target.node,
+		...target.nodeOptions,
+		target.client,
+		"--dir",
+		root
+	].map(shWord).join(" ");
+	return `#!/bin/sh\n# This app's door (acryl-door): reaches only the app running from this folder. Rewritten each time the app starts.\n${target.electron ? "export ELECTRON_RUN_AS_NODE=1\n" : ""}exec ${words} "$@"\n`;
+}
+function windowsShim(root, target) {
+	const words = [
+		target.node,
+		...target.nodeOptions,
+		target.client,
+		"--dir",
+		root
+	].map(cmdWord).join(" ");
+	return `@echo off\r\nsetlocal\r\nrem This app's door (acryl-door): reaches only the app running from this folder. Rewritten each time the app starts.\r\n${target.electron ? "set ELECTRON_RUN_AS_NODE=1\r\n" : ""}${words} %*\r\n`;
+}
+function writeAtomically(file, content, mode) {
+	const temporary = `${file}.${String(process.pid)}.tmp`;
+	writeFileSync(temporary, content, { mode });
+	if (process.platform !== "win32") chmodSync(temporary, mode);
+	renameSync(temporary, file);
+}
+/** Write `.acryl/bin/acryl` and `.acryl/bin/acryl.cmd` for the app at `root`. @returns the folder they are in. */
+function writeShims(root, target) {
+	const bin = join(ensureStateDir(root), "bin");
+	mkdirSync(bin, {
+		recursive: true,
+		mode: 448
+	});
+	if (process.platform !== "win32") chmodSync(bin, 448);
+	writeAtomically(join(bin, "acryl"), posixShim(root, target), 448);
+	writeAtomically(join(bin, "acryl.cmd"), windowsShim(root, target), 384);
+	return bin;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/index.ts
+/**
+* `acryl-door`: the Door of the five nouns, as a Cordis plugin of a framework app (spec 049 slice 9). An agent working in the app folder
+* looks at the running page, acts on it, and installs plugins live, through `.acryl/bin/acryl`; everything else it does with its own
+* file tools and shell.
+*
+* The page loads `/api/acryl-door/page.js` (one script tag) and keeps an event stream open to the Host; the Host sends it calls. An
+* operator on this machine reaches `/api/acryl-door/call` with the secret from `<app>/.acryl/door.json`. One effect owns the channel and
+* the audit, the routes are mounted after it, and a second effect writes the connection file last, so disposal removes the file first,
+* then the routes (their in-flight calls end), then closes the channel (every pending call settles).
+*/
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-door";
+const inject = [
+	"router",
+	"appInstance",
+	"nodeServer"
+];
+const Config = z.object({ tools: z.object({ expose: z.array(z.string().pattern(/^(?!door_)[A-Za-z][A-Za-z0-9_-]{0,63}$/u)).description("App tools (from the tools registry) the door offers; none by default.") }) });
+/** The page module, served compiled from source by the app's own TypeScript. */
+const PAGE_DIR = join(import.meta.dirname, import.meta.url.endsWith(".ts") ? "page" : join("..", "src", "page"));
+/** The operator client this build runs: the source next to this file, or the built `cli.js`. */
+const CLIENT = import.meta.url.endsWith(".ts") ? join(import.meta.dirname, "cli", "acryl.ts") : join(import.meta.dirname, "cli.js");
+/** How the folder's `.acryl/bin/acryl` starts the client: with the Node that runs the app, and its type-stripping flag when run from source. */
+function shimTarget() {
+	const fromSource = CLIENT.endsWith(".ts");
+	return {
+		node: process.execPath,
+		nodeOptions: fromSource ? process.execArgv.filter((option) => /^--experimental-(strip|transform)-types$/u.test(option)) : [],
+		client: CLIENT,
+		electron: process.versions.electron !== void 0
+	};
+}
+/** A listening address as one the operator reaches: an any-address bind is reached on loopback. */
+function loopbackUrl(url) {
+	const parsed = new URL(url);
+	if (parsed.hostname === "0.0.0.0" || parsed.hostname === "[::]") parsed.hostname = "127.0.0.1";
+	return parsed.origin;
+}
+function apply(ctx, rawConfig = {}) {
+	const config = Config(rawConfig);
+	const app = ctx.get("appInstance");
+	const server = ctx.get("nodeServer");
+	if (typeof app?.root !== "string") throw new Error("acryl-door: the appInstance service has no app folder (root)");
+	const reportError = (operation, cause) => {
+		ctx.logger?.error?.(`acryl-door: failed to ${operation}: ${cause instanceof Error ? cause.message : String(cause)}`);
+	};
+	const secret = newSecret();
+	const channel = new UiChannel();
+	const door = new Door({
+		channel,
+		audit: new AuditLog(auditPath(stateDir(app.root))),
+		app: {
+			name: app.name,
+			root: app.root
+		},
+		extensions: () => ctx.get("extensions"),
+		tools: () => ctx.get("tools"),
+		expose: config.tools?.expose ?? []
+	});
+	ctx.effect(() => () => {
+		channel.close();
+	}, "acryl-door: page channel");
+	const pageModule = new Acryl().get(`${DOOR_PREFIX}/page.js`, (c) => c.body(`import '${DOOR_PREFIX}/page/main.ts'\n`, 200, { "content-type": "text/javascript; charset=utf-8" })).route(`${DOOR_PREFIX}/page`, clientModules({ root: PAGE_DIR }));
+	ctx.router.route("/", privateApi(DOOR_PREFIX, pageModule, pageChannelRoutes(channel, { prefix: DOOR_PREFIX }), operatorRoutes(DOOR_PREFIX, secret, door, reportError), mcpRoutes(DOOR_PREFIX, secret, door, reportError)));
+	ctx.inject(["tools"], (inner) => {
+		inner.effect(() => registerChatTools(inner.get("tools"), door), "acryl-door: the verbs in the tools registry");
+	});
+	ctx.effect(function* () {
+		yield ctx.reflect.provide("door", door);
+		writeDoorFile(app.root, loopbackUrl(server.url), secret);
+		writeShims(app.root, shimTarget());
+		yield () => {
+			removeDoorFile(app.root, secret);
+		};
+	}, "acryl-door: the door service, .acryl/door.json and .acryl/bin/acryl");
+}
+//#endregion
+export { Config, DOOR_PREFIX, Door, DoorError, STATE_DIR, VERBS, VERB_SPECS, apply, chatToolName, doorFilePath, inject, mcpTools, name, readDoorFile };