@goodfellow-cms/mcp 0.0.0-stage → 0.3.0

package/dist/index.js

@@ -0,0 +1,813 @@
+import { COLLECTIONS_DIR, COLLECTION_SETTINGS_FILE, ConflictError, DraftError, FOOTER_FILE, GOODFELLOW_VERSION, HEADER_FILE, MEDIA_DIR, MEDIA_FILE, MENUS_FILE, PAGES_DIR, SITE_DESCRIPTION_PATH, SITE_FILE, SignInError, collectionFileSchema, entryAddress, entryFieldProblems, entryFileChange, isAddressSegment, isEmptyValue, isReservedPagePath, layoutFileChange, layoutFileSchema, mediaFileSchema, menusFileChange, menusFileSchema, newDraftName, normalizePagePath, pageFileChange, pageFileSchema, pageFileToPath, pagePathToFile, parseContentFile, parseEntryFile, parseSiteDescription, readTextFiles, siteSettingsFileChange, siteSettingsSchema, siteVersionProblem, writeChanges } from "@goodfellow-cms/core";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { cleanProps, objectSchema, slotNames, toContent, toFlatBlocks } from "@goodfellow-cms/ai/schema";
+import { z } from "zod";
+//#region src/content.ts
+/**
+* Reading a site's content a file at a time. Tools read only the files they
+* need, never the whole site, so a call stays within what a free hosting plan
+* allows however big the site is (the hosted connector's Worker gets 50
+* requests and 10 ms of processing per call).
+*/
+/** Thrown with a message Claude can pass on to the editor as it is. */
+var ToolError = class extends Error {
+	name = "ToolError";
+};
+function parsed(result) {
+	if (!result.ok) throw new ToolError(`${result.problem.file} ${result.problem.message} Fix it in the admin panel, or ask the site's developer.`);
+	return result.value;
+}
+async function readSettings(source) {
+	const text = await source.read(SITE_FILE);
+	return text === void 0 ? siteSettingsSchema.parse({ version: 1 }) : parsed(parseContentFile("site", siteSettingsSchema, SITE_FILE, text));
+}
+async function readMenus(source) {
+	const text = await source.read(MENUS_FILE);
+	return text === void 0 ? {} : parsed(parseContentFile("menus", menusFileSchema, MENUS_FILE, text)).menus;
+}
+async function readLayout(source, part) {
+	const file = part === "header" ? HEADER_FILE : FOOTER_FILE;
+	const text = await source.read(file);
+	return text === void 0 ? {
+		version: 1,
+		data: {
+			root: {},
+			content: []
+		}
+	} : parsed(parseContentFile("layout", layoutFileSchema, file, text));
+}
+/** A page's address written the site's one way, or a `ToolError` saying why it can't be one. */
+function pageAddress(input) {
+	try {
+		return normalizePagePath(input.trim().startsWith("/") ? input.trim() : `/${input.trim()}`);
+	} catch {
+		throw new ToolError(`"${input}" can't be a page's address. Addresses are like /about or /news/open-day: lowercase letters, numbers and hyphens.`);
+	}
+}
+/** The site's pages' addresses and files, from the list of files alone. */
+async function listPages(source) {
+	return (await source.list(PAGES_DIR)).filter((file) => file.endsWith(".json")).flatMap((file) => {
+		try {
+			return [{
+				address: pageFileToPath(file),
+				file
+			}];
+		} catch {
+			return [];
+		}
+	}).sort((a, b) => a.address.localeCompare(b.address));
+}
+async function readPage(source, address) {
+	const file = pagePathToFile(address);
+	const text = await source.read(file);
+	return text === void 0 ? void 0 : {
+		file,
+		content: parsed(parseContentFile("page", pageFileSchema, file, text))
+	};
+}
+/** The site's collections and their entries' files, from the list of files alone. */
+async function listCollections(source) {
+	const folders = /* @__PURE__ */ new Map();
+	for (const file of await source.list(COLLECTIONS_DIR)) {
+		const [id, name, ...rest] = file.slice(COLLECTIONS_DIR.length + 1).split("/");
+		if (!id || !name || rest.length > 0 || !isAddressSegment(id)) continue;
+		const folder = folders.get(id) ?? {
+			id,
+			file: `${COLLECTIONS_DIR}/${id}/${COLLECTION_SETTINGS_FILE}`,
+			entries: []
+		};
+		folders.set(id, folder);
+		if (name === COLLECTION_SETTINGS_FILE) continue;
+		const match = /^(.+)\.(json|md)$/.exec(name);
+		if (match?.[1] && isAddressSegment(match[1])) folder.entries.push({
+			slug: match[1],
+			file
+		});
+	}
+	return [...folders.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+/** A collection's settings and its entries' files. */
+async function readCollection(source, id) {
+	const collection = (await listCollections(source)).find((candidate) => candidate.id === id);
+	const text = collection && await source.read(collection.file);
+	if (!collection || text === void 0) throw new ToolError(`The site has no collection "${id}". list_collections lists the ones it has.`);
+	return {
+		...collection,
+		settings: parsed(parseContentFile("collection", collectionFileSchema, collection.file, text))
+	};
+}
+async function readEntry(source, collection, slug) {
+	const found = collection.entries.find((entry) => entry.slug === slug);
+	const text = found && await source.read(found.file);
+	if (!found || text === void 0) return void 0;
+	return {
+		file: found.file,
+		content: parsed(parseEntryFile(collection.settings, found.file, text))
+	};
+}
+/**
+* Every address the site's pages and entries have, so a new page or entry
+* never takes one. Entries' addresses come from their collections' settings.
+*/
+async function takenAddresses(source) {
+	const addresses = new Set((await listPages(source)).map((page) => page.address));
+	for (const collection of await listCollections(source)) {
+		const text = await source.read(collection.file);
+		if (text === void 0) continue;
+		const settings = parseContentFile("collection", collectionFileSchema, collection.file, text);
+		if (!settings.ok || settings.value.path === void 0) continue;
+		for (const entry of collection.entries) addresses.add(entryAddress(settings.value.path, entry.slug));
+	}
+	return addresses;
+}
+/** The site's media files, with their sizes and credits. */
+async function listMedia(source) {
+	const [files, sizes, creditsText] = await Promise.all([
+		source.list(MEDIA_DIR),
+		source.fileSizes?.(MEDIA_DIR),
+		source.read(MEDIA_FILE)
+	]);
+	const credits = creditsText === void 0 ? {} : parsed(parseContentFile("media", mediaFileSchema, MEDIA_FILE, creditsText)).credits;
+	return files.sort().map((file) => {
+		const address = `/${file.slice(7)}`;
+		const bytes = sizes?.get(file);
+		const credit = credits[address];
+		return {
+			address,
+			...bytes !== void 0 && { bytes },
+			...credit && { credit }
+		};
+	});
+}
+/** Image types a browser shows on their own, which `screenshot` can take a picture of. */
+const IMAGE_ADDRESS = /^\/media\/[^?#]+\.(?:jpe?g|png|gif|webp|avif|svg|ico)$/i;
+/** Whether an address is a media file's, rather than a page's. */
+function isMediaAddress(address) {
+	return address.trim().startsWith("/media/");
+}
+/** An image's address in the media library, or a `ToolError` saying why it can't be shown. */
+async function mediaImage(source, input) {
+	const address = input.trim();
+	if (!IMAGE_ADDRESS.test(address) || address.split("/").some((part) => part === ".." || part === ".")) throw new ToolError(`${address} isn't an image Claude can look at. Screenshots show pages, and images in the media library such as /media/photo.jpg; other files, such as PDFs and videos, are opened in the admin panel.`);
+	if (!(await source.list(MEDIA_DIR)).includes(`public${address}`)) throw new ToolError(`There's no file at ${address}. list_media lists the media library.`);
+	return address;
+}
+/** Every content file, as text: what the preview page needs to show a draft as the site would. */
+async function contentFiles(source) {
+	return Object.fromEntries(await readTextFiles(source, await source.list("content")));
+}
+//#endregion
+//#region src/site.ts
+/**
+* Opening a site for the tools: its backend, its settings, and the
+* description its build published (`goodfellow-site.json`), which says what
+* blocks it has, since the connector doesn't have the site's code.
+*/
+function configFrom(description, templates) {
+	return {
+		components: Object.fromEntries(Object.entries(description.blocks).filter(([, block]) => templates || !block.templateOnly).map(([name, block]) => [name, {
+			...block.label && { label: block.label },
+			fields: block.fields,
+			...block.defaultProps && { defaultProps: block.defaultProps },
+			render: () => null
+		}])),
+		root: { fields: description.root.fields }
+	};
+}
+const VERSION_PROBLEMS = {
+	"site-too-old": (site) => `The site was built with Goodfellow ${site}, which is too old for Claude to change it. Ask the site's owner to update it on the admin panel's Updates screen; reading it still works.`,
+	"tool-too-old": (site) => `The site was built with Goodfellow ${site}, which is newer than this connector (${GOODFELLOW_VERSION}). Update the connector to change it; reading it still works.`
+};
+async function openSite(context, id) {
+	const backend = await context.backend(id);
+	await backend.revision();
+	const settings = await readSettings(backend);
+	if (!settings.url) throw new ToolError("The site doesn't have its address in Site settings yet, and Claude needs it to see what blocks the site has. Set it in the admin panel's Site settings.");
+	const url = settings.url.replace(/\/+$/, "");
+	const response = await (context.fetch ?? fetch)(`${url}/${SITE_DESCRIPTION_PATH}`, { headers: { accept: "application/json" } }).catch(() => void 0);
+	const result = response?.ok ? parseSiteDescription(await response.text()) : { ok: false };
+	if (!result.ok) throw new ToolError(`Claude couldn't read what blocks the site has from ${url}/${SITE_DESCRIPTION_PATH}. The site may not be online yet, or was built before Goodfellow could work with Claude: publish any change in the admin panel to rebuild it.`);
+	const { description } = result;
+	const problem = siteVersionProblem(description);
+	return {
+		id,
+		backend,
+		settings,
+		url,
+		description,
+		pageConfig: configFrom(description, false),
+		templateConfig: configFrom(description, true),
+		...problem && { versionProblem: VERSION_PROBLEMS[problem](description.goodfellow) }
+	};
+}
+//#endregion
+//#region src/tools.ts
+/**
+* The Claude connector's tools. Changes always go into a draft (a branch of
+* the site's repository), which Claude shows the editor in screenshots, then
+* publishes or submits for review when the editor says so. The tools keep
+* nothing between calls: the draft's name, which every change returns, is how
+* Claude carries on with one.
+*/
+/** What Claude is told about working with Goodfellow sites. */
+const INSTRUCTIONS = `These tools edit websites built with Goodfellow, for people who aren't developers.
+
+- Start with get_site, which lists the site's pages, collections and blocks.
+- Changes are saved in a draft, never straight to the live site. The first change starts one and returns its name: pass that name as "draft" to every later change and read, so they build on each other.
+- Pages, the header and the footer are made of blocks. get_blocks says which blocks the site has and what each one's props are. Blocks are written as a flat list in page order: a block inside another names it as "parent", and which of its places it goes in as "slot".
+- Show the editor what a draft looks like with screenshot before anything goes live.
+- Only publish when the editor says to. If they'd like someone to check it first, use submit_for_review instead.
+- Use the site's own words for things: say "publish", not "commit" or "merge".`;
+/** Why `publish` refuses, on sites whose config says `claude: { publish: false }`. */
+const NO_PUBLISHING = "The site's owner has turned off publishing from Claude. Submit the draft for review instead (submit_for_review), and someone who looks after the site publishes it.";
+const siteArg = z.string().optional().describe("Which site, from list_sites. Leave it out when there's only one.");
+const draftArg = z.string().optional().describe("The draft, as an earlier change returned it. To read: leave it out for the live site. To change: leave it out to start a new draft.");
+const flatBlock = z.object({
+	type: z.string().describe("The block's name, from get_blocks."),
+	id: z.string().describe("A short id, unique in this list, such as b1."),
+	parent: z.string().nullable().describe("The id of the block this one is inside, listed earlier, or null."),
+	slot: z.string().nullable().describe("Which place in the parent block this one goes in, or null."),
+	props: z.record(z.string(), z.unknown()).describe("The block's props, as get_blocks describes them.")
+});
+function text(value) {
+	return { content: [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}] };
+}
+function base64(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(binary);
+}
+function failure(message) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: message
+		}]
+	};
+}
+/** Turns what went wrong into words the editor can act on. Never includes a token: backends' errors don't. */
+function explain(error) {
+	if (error instanceof ToolError) return failure(error.message);
+	if (error instanceof DraftError) {
+		if (error.problem === "not-found") return failure("That draft isn't there any more: it may have been published or discarded. Make the change again without a draft to start a new one.");
+		if (error.problem === "no-reviews") return failure("This sign-in can't ask for a review on the site's host. Publish the draft instead, if the editor agrees, or ask the site's owner.");
+		return failure(error.message);
+	}
+	if (error instanceof ConflictError) return failure("Someone changed the same part of the site while this was being saved. Read it again (with the draft), then make the change again.");
+	if (error instanceof SignInError) return failure(error.problem === "cant-publish" ? "This sign-in can read the site but can't change it. Ask the site's owner to give you permission to edit it." : "Signing in to the site's host didn't work. Connect Claude to the site again.");
+	return failure(`Something went wrong: ${error.message ?? String(error)}`);
+}
+function countBlocks(content, config) {
+	return content.reduce((count, block) => {
+		const component = config.components[block.type];
+		const nested = slotNames(component).reduce((inner, slot) => inner + countBlocks(block.props[slot] ?? [], config), 0);
+		return count + 1 + nested;
+	}, 0);
+}
+function newId(type) {
+	return `${type}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function blocksFrom(blocks, config) {
+	const content = toContent({ blocks }, config, newId);
+	return {
+		content,
+		ignored: blocks.length - countBlocks(content, config)
+	};
+}
+function registerTools(server, context) {
+	const now = context.now ?? (() => /* @__PURE__ */ new Date());
+	async function siteId(given) {
+		if (given) return given;
+		const sites = await context.sites();
+		const [only] = sites;
+		if (sites.length === 1 && only) return only.id;
+		throw new ToolError(sites.length === 0 ? "Claude isn't connected to any sites yet. Connect it to a site first." : `Say which site: ${sites.map((site) => site.id).join(", ")}.`);
+	}
+	async function open(given) {
+		return openSite(context, await siteId(given));
+	}
+	async function draftOf(site, name) {
+		if (!site.backend.drafts) throw new ToolError("This site's host can't keep drafts, which Claude's changes need.");
+		return site.backend.drafts.open(name);
+	}
+	/** The draft to change: the one named, or a new one. Refuses sites that can't take changes. */
+	async function changing(site, name) {
+		if (site.versionProblem) throw new ToolError(site.versionProblem);
+		if (name) return draftOf(site, name);
+		if (!site.backend.drafts) throw new ToolError("This site's host can't keep drafts, which Claude's changes need.");
+		return site.backend.drafts.create(newDraftName(now()));
+	}
+	/** Where to read from: a draft, or the live site. */
+	async function reading(site, name) {
+		return name ? (await draftOf(site, name)).store : site.backend;
+	}
+	async function save(draft, changes, message) {
+		const store = draft.store;
+		await writeChanges(store, changes, {
+			message,
+			expectedRevision: await store.revision()
+		});
+	}
+	function tool(name, description, shape, run, readOnly = false) {
+		server.registerTool(name, {
+			description,
+			inputSchema: shape,
+			annotations: {
+				readOnlyHint: readOnly,
+				destructiveHint: false
+			}
+		}, (async (args) => {
+			try {
+				return await run(args);
+			} catch (error) {
+				return explain(error);
+			}
+		}));
+	}
+	tool("list_sites", "The Goodfellow sites this connection can edit.", {}, async () => text((await context.sites()).map((site) => ({
+		site: site.id,
+		...site.label && { name: site.label }
+	}))), true);
+	tool("get_site", "An overview of a site: its name and address, pages, collections, menus and blocks. Start here.", {
+		site: siteArg,
+		draft: draftArg
+	}, async ({ site: given, draft }) => {
+		const site = await open(given);
+		const source = await reading(site, draft);
+		const [pages, collections, menus] = await Promise.all([
+			listPages(source),
+			listCollections(source),
+			readMenus(source)
+		]);
+		return text({
+			site: site.id,
+			name: site.settings.title,
+			address: site.url,
+			...site.versionProblem && { cantChange: site.versionProblem },
+			...site.description.claude?.publish === false && { cantPublish: NO_PUBLISHING },
+			...site.settings.theme.darkMode && { darkMode: true },
+			pages: pages.map((page) => page.address),
+			collections: collections.map((collection) => ({
+				id: collection.id,
+				entries: collection.entries.length
+			})),
+			menus: Object.keys(menus),
+			blocks: Object.entries(site.description.blocks).map(([name, block]) => ({
+				name,
+				...block.label && { label: block.label },
+				...block.templateOnly && { onlyInCollectionTemplates: true }
+			}))
+		});
+	}, true);
+	tool("get_blocks", "What each of the site's blocks is and the props it takes, as JSON Schema, and the places in it where other blocks go (slots). Also the page settings' props.", {
+		site: siteArg,
+		names: z.array(z.string()).optional().describe("Only these blocks. Leave it out for all of them.")
+	}, async ({ site: given, names }) => {
+		const site = await open(given);
+		const blocks = Object.entries(site.templateConfig.components).filter(([name]) => !names || names.includes(name));
+		return text({
+			pageSettings: objectSchema(site.description.root.fields) ?? {},
+			blocks: blocks.map(([name, component]) => ({
+				name,
+				...component.label && { label: component.label },
+				slots: slotNames(component),
+				...site.description.blocks[name]?.templateOnly && { onlyInCollectionTemplates: true },
+				props: objectSchema(component.fields) ?? {}
+			}))
+		});
+	}, true);
+	tool("get_page", "A page's settings (such as its title) and its blocks, as a flat list.", {
+		site: siteArg,
+		address: z.string().describe("The page's address, such as / or /about."),
+		draft: draftArg
+	}, async ({ site: given, address, draft }) => {
+		const site = await open(given);
+		const path = pageAddress(address);
+		const page = await readPage(await reading(site, draft), path);
+		if (!page) throw new ToolError(`The site has no page at ${path}. get_site lists its pages.`);
+		return text({
+			address: path,
+			settings: page.content.data.root.props ?? {},
+			blocks: toFlatBlocks(page.content.data.content, site.pageConfig)
+		});
+	}, true);
+	tool("save_page", "Creates a page, or changes one, in a draft. Give the whole list of blocks: it replaces the page's blocks. Leave blocks out to change only its settings.", {
+		site: siteArg,
+		address: z.string().describe("The page's address, such as /about. A new address makes a new page."),
+		draft: draftArg,
+		settings: z.record(z.string(), z.unknown()).optional().describe("Page settings to change, such as title and description, as get_blocks describes them."),
+		blocks: z.array(flatBlock).optional()
+	}, async ({ site: given, address, draft: name, settings, blocks }) => {
+		const site = await open(given);
+		const path = pageAddress(address);
+		const draft = await changing(site, name);
+		const existing = await readPage(draft.store, path);
+		if (!existing) {
+			if (isReservedPagePath(path)) throw new ToolError(`${path} is kept for the admin panel. Choose another address.`);
+			if ((await takenAddresses(draft.store)).has(path)) throw new ToolError(`${path} is already a collection item's address. Choose another one.`);
+		}
+		const before = existing?.content.data ?? {
+			root: { props: {} },
+			content: []
+		};
+		const props = {
+			...before.root.props ?? {},
+			...cleanProps(site.description.root.fields, settings ?? {}, void 0)
+		};
+		const built = blocks ? blocksFrom(blocks, site.pageConfig) : {
+			content: before.content,
+			ignored: 0
+		};
+		const data = {
+			...before,
+			root: {
+				...before.root,
+				props
+			},
+			content: built.content
+		};
+		const title = typeof props.title === "string" && props.title ? props.title : path;
+		await save(draft, [pageFileChange(path, data)], `${existing ? "Update" : "Add"} page "${title}"`);
+		return text({
+			draft: draft.name,
+			address: path,
+			saved: existing ? "changed" : "created",
+			...built.ignored > 0 && { ignored: `${built.ignored} block(s) weren't saved: their type isn't one of the site's blocks, or they were in a block that wasn't.` }
+		});
+	});
+	tool("delete_page", "Deletes a page, in a draft.", {
+		site: siteArg,
+		address: z.string(),
+		draft: draftArg
+	}, async ({ site: given, address, draft: name }) => {
+		const site = await open(given);
+		const path = pageAddress(address);
+		if (path === "/") throw new ToolError("The home page can't be deleted. Change it instead.");
+		const draft = await changing(site, name);
+		const page = await readPage(draft.store, path);
+		if (!page) throw new ToolError(`The site has no page at ${path}.`);
+		await save(draft, [{
+			path: page.file,
+			delete: true
+		}], `Delete page ${path}`);
+		return text({
+			draft: draft.name,
+			address: path,
+			saved: "deleted"
+		});
+	});
+	tool("get_layout", "The site's header or footer: its blocks, as a flat list. Every page shows them.", {
+		site: siteArg,
+		part: z.enum(["header", "footer"]),
+		draft: draftArg
+	}, async ({ site: given, part, draft }) => {
+		const site = await open(given);
+		const layout = await readLayout(await reading(site, draft), part);
+		return text({
+			part,
+			blocks: toFlatBlocks(layout.data.content, site.pageConfig)
+		});
+	}, true);
+	tool("save_layout", "Changes the site's header or footer, in a draft. Give the whole list of blocks: it replaces them.", {
+		site: siteArg,
+		part: z.enum(["header", "footer"]),
+		draft: draftArg,
+		blocks: z.array(flatBlock)
+	}, async ({ site: given, part, draft: name, blocks }) => {
+		const site = await open(given);
+		const draft = await changing(site, name);
+		const before = await readLayout(draft.store, part);
+		const built = blocksFrom(blocks, site.pageConfig);
+		await save(draft, [layoutFileChange(part === "header" ? HEADER_FILE : FOOTER_FILE, {
+			...before.data,
+			content: built.content
+		})], `Update ${part}`);
+		return text({
+			draft: draft.name,
+			part,
+			saved: "changed",
+			...built.ignored > 0 && { ignored: built.ignored }
+		});
+	});
+	tool("get_collection", "A collection (such as news or events): its fields, the address its items have, and its items.", {
+		site: siteArg,
+		collection: z.string().describe("The collection's id, from get_site."),
+		draft: draftArg
+	}, async ({ site: given, collection: id, draft }) => {
+		const collection = await readCollection(await reading(await open(given), draft), id);
+		const { settings } = collection;
+		return text({
+			id,
+			name: settings.name,
+			itemName: settings.entryName,
+			...settings.path !== void 0 && { address: settings.path },
+			...settings.markdown && { markdownField: settings.markdown.body },
+			fields: settings.fields,
+			items: collection.entries.map((entry) => ({
+				slug: entry.slug,
+				...settings.path !== void 0 && { address: entryAddress(settings.path, entry.slug) }
+			}))
+		});
+	}, true);
+	tool("get_item", "One item of a collection: its fields' values.", {
+		site: siteArg,
+		collection: z.string(),
+		slug: z.string(),
+		draft: draftArg
+	}, async ({ site: given, collection: id, slug, draft }) => {
+		const source = await reading(await open(given), draft);
+		const entry = await readEntry(source, await readCollection(source, id), slug);
+		if (!entry) throw new ToolError(`The collection "${id}" has no item "${slug}".`);
+		return text({
+			collection: id,
+			slug,
+			values: entry.content.fields
+		});
+	}, true);
+	tool("save_item", "Creates an item of a collection, or changes one, in a draft. Values not given stay as they are. Formatted text is simple HTML; a collection's Markdown field is Markdown.", {
+		site: siteArg,
+		collection: z.string(),
+		slug: z.string().describe("The item's name in its address and file: lowercase letters, numbers and hyphens, such as open-day."),
+		values: z.record(z.string(), z.unknown()).describe("Field values, by the fields' names from get_collection."),
+		draft: draftArg
+	}, async ({ site: given, collection: id, slug, values, draft: name }) => {
+		const draft = await changing(await open(given), name);
+		const collection = await readCollection(draft.store, id);
+		const existing = await readEntry(draft.store, collection, slug);
+		if (!existing) {
+			if (!isAddressSegment(slug)) throw new ToolError(`"${slug}" can't be an item's name: use lowercase letters, numbers and hyphens.`);
+			const path = collection.settings.path === void 0 ? void 0 : entryAddress(collection.settings.path, slug);
+			if (path && (isReservedPagePath(path) || (await takenAddresses(draft.store)).has(path))) throw new ToolError(`${path} is already taken on the site. Choose another name.`);
+		}
+		const known = new Set(collection.settings.fields.map((field) => field.name));
+		const unknown = Object.keys(values).filter((field) => !known.has(field));
+		if (unknown.length > 0) throw new ToolError(`The collection has no field ${unknown.join(", ")}. get_collection lists its fields.`);
+		const fields = {
+			...existing?.content.fields ?? {},
+			...values
+		};
+		const problems = entryFieldProblems(collection.settings.fields, fields);
+		if (problems.length > 0) throw new ToolError(`Those values don't fit the fields: ${problems.join("; ")}.`);
+		const missing = collection.settings.fields.filter((field) => field.required && isEmptyValue(fields[field.name]));
+		if (missing.length > 0) throw new ToolError(`The item needs a value for: ${missing.map((field) => field.name).join(", ")}.`);
+		const change = entryFileChange({
+			id,
+			settings: collection.settings
+		}, slug, fields);
+		const title = typeof fields.title === "string" ? fields.title : slug;
+		await save(draft, [change], `${existing ? "Update" : "Add"} ${collection.settings.entryName.toLowerCase()} "${title}"`);
+		return text({
+			draft: draft.name,
+			collection: id,
+			slug,
+			saved: existing ? "changed" : "created"
+		});
+	});
+	tool("delete_item", "Deletes an item of a collection, in a draft.", {
+		site: siteArg,
+		collection: z.string(),
+		slug: z.string(),
+		draft: draftArg
+	}, async ({ site: given, collection: id, slug, draft: name }) => {
+		const draft = await changing(await open(given), name);
+		const collection = await readCollection(draft.store, id);
+		const entry = collection.entries.find((candidate) => candidate.slug === slug);
+		if (!entry) throw new ToolError(`The collection "${id}" has no item "${slug}".`);
+		await save(draft, [{
+			path: entry.file,
+			delete: true
+		}], `Delete ${collection.settings.entryName.toLowerCase()} ${slug}`);
+		return text({
+			draft: draft.name,
+			collection: id,
+			slug,
+			saved: "deleted"
+		});
+	});
+	tool("get_settings", "The site's settings: its name, description, logo, theme colors and fonts, contact details and the like.", {
+		site: siteArg,
+		draft: draftArg
+	}, async ({ site: given, draft }) => {
+		return text(await readSettings(await reading(await open(given), draft)));
+	}, true);
+	tool("update_settings", "Changes some of the site's settings, in a draft. Settings not given stay as they are. The site's address is changed on the admin panel's Domain screen instead.", {
+		site: siteArg,
+		settings: z.record(z.string(), z.unknown()),
+		draft: draftArg
+	}, async ({ site: given, settings: changes, draft: name }) => {
+		const draft = await changing(await open(given), name);
+		const current = await readSettings(draft.store);
+		if ("url" in changes && changes.url !== current.url) throw new ToolError("The site's address is changed on the admin panel's Domain screen, not by Claude.");
+		const result = siteSettingsSchema.safeParse({
+			...current,
+			...changes,
+			version: current.version
+		});
+		if (!result.success) throw new ToolError(`Those settings don't fit: ${result.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("; ")}.`);
+		await save(draft, [siteSettingsFileChange(result.data)], "Update site settings");
+		return text({
+			draft: draft.name,
+			saved: "changed"
+		});
+	});
+	tool("get_menus", "The site's menus, by name: each a list of links, which can have links of their own under them.", {
+		site: siteArg,
+		draft: draftArg
+	}, async ({ site: given, draft }) => {
+		return text(await readMenus(await reading(await open(given), draft)));
+	}, true);
+	tool("save_menu", "Replaces one of the site's menus, in a draft: a list of links, each with a label and an href.", {
+		site: siteArg,
+		menu: z.string().describe("The menu's name, such as main or footer."),
+		items: z.array(z.unknown()),
+		draft: draftArg
+	}, async ({ site: given, menu, items, draft: name }) => {
+		const draft = await changing(await open(given), name);
+		const menus = await readMenus(draft.store);
+		const result = menusFileSchema.safeParse({
+			version: 1,
+			menus: {
+				...menus,
+				[menu]: items
+			}
+		});
+		if (!result.success) throw new ToolError(`That menu doesn't fit: ${result.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("; ")}.`);
+		await save(draft, [menusFileChange(result.data.menus)], `Update menu "${menu}"`);
+		return text({
+			draft: draft.name,
+			menu,
+			saved: "changed"
+		});
+	});
+	tool("list_media", "The site's uploaded images and files: the address blocks use for each, such as /media/photo.jpg, its size in bytes, and its credit if it has one. Pages that use a credited file show its credit by themselves, as its license requires, so use it as it is. To see an image, take a screenshot of its address. New files are uploaded in the admin panel.", { site: siteArg }, async ({ site: given }) => {
+		return text(await listMedia((await open(given)).backend));
+	}, true);
+	tool("get_draft", "What a draft changes compared with the live site.", {
+		site: siteArg,
+		draft: z.string()
+	}, async ({ site: given, draft: name }) => {
+		const draft = await draftOf(await open(given), name);
+		const changes = await draft.changes();
+		return text({
+			draft: draft.name,
+			changes: changes.map((change) => {
+				const kind = "delete" in change ? "deleted" : "changed";
+				if (change.path.startsWith("content/pages/")) return {
+					page: pageFileToPath(change.path),
+					[kind]: true
+				};
+				return {
+					file: change.path,
+					[kind]: true
+				};
+			})
+		});
+	}, true);
+	if (context.screenshots) {
+		const screenshots = context.screenshots;
+		tool("screenshot", "A picture of a page, as it is on the live site or with a draft's changes, or of an image in the media library (its address from list_media), to see what it shows. Show pages to the editor before publishing.", {
+			site: siteArg,
+			address: z.string().describe("A page's address, such as /about, or an image's, such as /media/photo.jpg."),
+			draft: draftArg,
+			width: z.union([
+				z.literal(390),
+				z.literal(768),
+				z.literal(1280)
+			]).optional().describe("390 for a phone, 768 for a tablet, 1280 (the default) for a computer."),
+			dark: z.boolean().optional().describe("Shows the page as visitors whose computer is set to dark see it, on sites with dark mode.")
+		}, async ({ site: given, address, draft: name, width = 1280, dark = false }) => {
+			const site = await open(given);
+			if (isMediaAddress(address)) {
+				const image = await mediaImage(site.backend, address);
+				return { content: [{
+					type: "image",
+					data: base64(await screenshots.take({
+						url: `${site.url}${image}`,
+						width,
+						image: true,
+						dark
+					})),
+					mimeType: "image/png"
+				}] };
+			}
+			const path = pageAddress(address);
+			return { content: [{
+				type: "image",
+				data: base64(name ? await screenshots.take({
+					url: `${site.url}/admin/#/preview`,
+					width,
+					dark,
+					preview: {
+						files: await contentFiles((await draftOf(site, name)).store),
+						path,
+						dark
+					}
+				}) : await screenshots.take({
+					url: `${site.url}${path === "/" ? "/" : path}`,
+					width,
+					dark
+				})),
+				mimeType: "image/png"
+			}] };
+		}, true);
+	}
+	tool("publish", "Publishes a draft: its changes go live, in one go, and the draft is removed. Only when the editor has said to, and not on sites whose owner has turned it off (get_site says so); submit_for_review instead.", {
+		site: siteArg,
+		draft: z.string(),
+		message: z.string().describe("What the changes are, in a few words, such as \"New page about the summer fair\".")
+	}, async ({ site: given, draft: name, message }) => {
+		const site = await open(given);
+		if (site.versionProblem) throw new ToolError(site.versionProblem);
+		if (site.description.claude?.publish === false) throw new ToolError(NO_PUBLISHING);
+		const draft = await draftOf(site, name);
+		try {
+			await draft.publish(message);
+		} catch (error) {
+			if (error instanceof ConflictError) throw new ToolError("Someone published changes to the same pages since this draft started, so publishing it would undo theirs. The draft is still there: read the pages again from the live site, make the changes again in a new draft, then publish that.");
+			throw error;
+		}
+		return text({
+			published: true,
+			note: "The site is being rebuilt with the changes, which usually takes a minute or two.",
+			address: site.url
+		});
+	});
+	tool("submit_for_review", "Asks for a draft to be checked before it goes live: someone who looks after the site reviews it on GitHub or GitLab, and publishes it from there.", {
+		site: siteArg,
+		draft: z.string(),
+		title: z.string().describe("What the changes are, in a few words."),
+		description: z.string().optional().describe("More about the changes, for whoever reviews them.")
+	}, async ({ site: given, draft: name, title, description }) => {
+		return text({
+			submitted: true,
+			review: (await (await draftOf(await open(given), name)).submitForReview({
+				title,
+				...description && { description }
+			})).url
+		});
+	});
+	tool("discard_draft", "Throws a draft and its changes away. The live site isn't affected.", {
+		site: siteArg,
+		draft: z.string()
+	}, async ({ site: given, draft: name }) => {
+		await (await draftOf(await open(given), name)).discard();
+		return text({ discarded: true });
+	});
+}
+//#endregion
+//#region src/image-page.ts
+/**
+* A page showing one image at most as wide as the screenshot, which both
+* screenshot setups open in place of the image's own address: browsers show
+* an image opened on its own in a document of their own, which can't always
+* be screenshotted (an SVG's never finishes).
+*/
+function attribute(text) {
+	return text.replace(/[&"<>]/g, (character) => ({
+		"&": "&amp;",
+		"\"": "&quot;",
+		"<": "&lt;",
+		">": "&gt;"
+	})[character] ?? "");
+}
+function imagePage(url) {
+	return `<!doctype html>
+<html><head><meta charset="utf-8"><style>
+html, body { margin: 0; background: #fff; }
+img { display: block; max-width: 100%; height: auto; }
+img[src$=".svg" i] { width: 100%; }
+</style></head>
+<body><img src="${attribute(url)}" alt=""></body></html>`;
+}
+//#endregion
+//#region src/index.ts
+/**
+* The Claude connector's tools, for any MCP server: the one on the editor's
+* computer (`goodfellow-mcp`) and the hosted connector's Worker.
+*/
+/** Splits a site's id into its host and repository, or `undefined` if it isn't one. */
+function parseSiteId(id) {
+	const match = /^(github|gitlab):([\w.-]+(?:\/[\w.-]+)+)$/.exec(id.trim());
+	if (!match) return void 0;
+	const [, host, repo] = match;
+	if (host === "github" && repo?.split("/").length !== 2) return void 0;
+	return {
+		host,
+		repo: repo ?? ""
+	};
+}
+/** An MCP server with Goodfellow's tools. Connect it to a transport. */
+function createGoodfellowServer(context) {
+	const server = new McpServer({
+		name: "goodfellow",
+		version: GOODFELLOW_VERSION
+	}, { instructions: INSTRUCTIONS });
+	registerTools(server, context);
+	return server;
+}
+//#endregion
+export { INSTRUCTIONS, ToolError, contentFiles, createGoodfellowServer, imagePage, parseSiteId };