@goodfellow-cms/mcp 0.0.0-stage → 0.2.0

package/dist/stdio.js

@@ -0,0 +1,690 @@
+#!/usr/bin/env node
+import { a as listCollections, c as mediaImage, d as readEntry, f as readLayout, g as takenAddresses, h as readSettings, i as isMediaAddress, l as pageAddress, m as readPage, n as ToolError, o as listMedia, p as readMenus, r as contentFiles, s as listPages, t as localScreenshots, u as readCollection } from "./screenshots--uulXZYY.js";
+import { github } from "@goodfellow-cms/github";
+import { gitlab } from "@goodfellow-cms/gitlab";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ConflictError, DraftError, FOOTER_FILE, GOODFELLOW_VERSION, HEADER_FILE, SITE_DESCRIPTION_PATH, SignInError, entryAddress, entryFieldProblems, entryFileChange, isAddressSegment, isEmptyValue, isReservedPagePath, layoutFileChange, menusFileChange, menusFileSchema, newDraftName, pageFileChange, pageFileToPath, parseSiteDescription, 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/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 site = await open(given);
+		const collection = await readCollection(await reading(site, 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 collection = await readCollection(source, id);
+		const entry = await readEntry(source, collection, 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 }) => {
+		const site = await open(given);
+		return text(await readSettings(await reading(site, 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 }) => {
+		const site = await open(given);
+		return text(await readMenus(await reading(site, 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 }) => {
+		const site = await open(given);
+		return text(await listMedia(site.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/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
+//#region src/stdio.ts
+/** Sign-ins keep nothing on disk: the token comes from the environment every time. */
+function memoryStorage() {
+	const items = /* @__PURE__ */ new Map();
+	return {
+		getItem: (key) => items.get(key) ?? null,
+		setItem: (key, value) => void items.set(key, value),
+		removeItem: (key) => void items.delete(key)
+	};
+}
+function fail(message) {
+	process.stderr.write(`goodfellow-mcp: ${message}\n`);
+	process.exit(1);
+}
+const siteId = process.env.GOODFELLOW_SITE?.trim() || process.argv[2];
+const token = process.env.GOODFELLOW_TOKEN?.trim();
+if (!siteId) fail("Set GOODFELLOW_SITE to the site's repository, such as github:owner/site or gitlab:group/site.");
+const site = parseSiteId(siteId);
+if (!site) fail(`${siteId} isn't a site. Write it as github:owner/site or gitlab:group/site.`);
+if (!token) fail("Set GOODFELLOW_TOKEN to a GitHub or GitLab token that can edit the site.");
+const storage = {
+	local: memoryStorage(),
+	session: memoryStorage()
+};
+const host = site.host === "github" ? github({
+	repo: site.repo,
+	signIn: false,
+	storage
+}) : gitlab({
+	project: site.repo,
+	...process.env.GITLAB_URL && { url: process.env.GITLAB_URL },
+	storage
+});
+let signedIn;
+await createGoodfellowServer({
+	sites: async () => [{ id: siteId }],
+	backend: async (id) => {
+		if (id !== siteId) throw new ToolError(`This connector only edits ${siteId}.`);
+		signedIn ??= host.signInWithToken(token, false).catch((error) => {
+			signedIn = void 0;
+			throw error;
+		});
+		return signedIn;
+	},
+	screenshots: localScreenshots(process.env.GOODFELLOW_BROWSER ? { executablePath: process.env.GOODFELLOW_BROWSER } : {})
+}).connect(new StdioServerTransport());
+//#endregion
+export {};