@goodfellow-cms/mcp 0.0.0-stage → 0.2.0

package/dist/screenshots--uulXZYY.js

@@ -0,0 +1,240 @@
+import { COLLECTIONS_DIR, COLLECTION_SETTINGS_FILE, FOOTER_FILE, HEADER_FILE, MEDIA_DIR, MEDIA_FILE, MENUS_FILE, PAGES_DIR, SITE_FILE, collectionFileSchema, entryAddress, isAddressSegment, layoutFileSchema, mediaFileSchema, menusFileSchema, normalizePagePath, pageFileSchema, pageFileToPath, pagePathToFile, parseContentFile, parseEntryFile, readTextFiles, siteSettingsSchema } from "@goodfellow-cms/core";
+//#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/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/screenshots.ts
+/**
+* Screenshots on the editor's computer, with the Chrome or Microsoft Edge
+* it already has, through Playwright. Nothing is downloaded: without either
+* browser, the screenshot tool says so.
+*/
+/** How long a page may take to load and settle. */
+const TIMEOUT = 3e4;
+function localScreenshots(options = {}) {
+	return { async take({ url, width, preview, image, dark }) {
+		let chromium;
+		try {
+			({chromium} = await import("playwright-core"));
+		} catch {
+			throw new ToolError("Screenshots aren't available: this copy of the connector was installed without them.");
+		}
+		const attempts = options.executablePath ? [{ executablePath: options.executablePath }] : [{ channel: "chrome" }, { channel: "msedge" }];
+		let browser;
+		for (const attempt of attempts) {
+			browser = await chromium.launch({
+				...attempt,
+				headless: true
+			}).catch(() => void 0);
+			if (browser) break;
+		}
+		if (!browser) throw new ToolError("Screenshots need Google Chrome or Microsoft Edge on this computer, or GOODFELLOW_BROWSER set to another Chromium-based browser.");
+		try {
+			const page = await browser.newPage({
+				viewport: {
+					width,
+					height: 900
+				},
+				colorScheme: dark ? "dark" : "light"
+			});
+			if (image) await page.setContent(imagePage(url), {
+				waitUntil: "networkidle",
+				timeout: TIMEOUT
+			});
+			else await page.goto(url, {
+				waitUntil: "networkidle",
+				timeout: TIMEOUT
+			});
+			if (preview) {
+				await page.waitForFunction(() => typeof window.goodfellowPreview === "function", null, { timeout: TIMEOUT });
+				const result = await page.evaluate((request) => window.goodfellowPreview?.(request), preview);
+				if (!result?.ok) throw new ToolError(`The draft couldn't be shown: ${result?.problem ?? "the site's preview page didn't answer"}`);
+				await page.waitForLoadState("networkidle", { timeout: TIMEOUT });
+			}
+			return new Uint8Array(await page.screenshot({
+				fullPage: true,
+				type: "png"
+			}));
+		} finally {
+			await browser.close();
+		}
+	} };
+}
+//#endregion
+export { listCollections as a, mediaImage as c, readEntry as d, readLayout as f, takenAddresses as g, readSettings as h, isMediaAddress as i, pageAddress as l, readPage as m, ToolError as n, listMedia as o, readMenus as p, contentFiles as r, listPages as s, localScreenshots as t, readCollection as u };

package/dist/screenshots.d.ts

@@ -0,0 +1,29 @@
+import "@goodfellow-cms/core";
+import "@puckeditor/core";
+//#region src/site.d.ts
+interface Screenshotter {
+  /**
+   * A PNG of a page at `url`, `width` pixels wide and as tall as the page. With
+   * `preview`, `url` is the site's preview page (`/admin/#/preview`), which is
+   * handed a draft's content files and shows the page at `preview.path`.
+   */
+  take(options: {
+    url: string;
+    width: number;
+    preview?: {
+      files: Record<string, string>;
+      path: string;
+      dark?: boolean;
+    };
+    /** `url` is an image's, shown on a page of its own (`imagePage()`), no wider than `width`. */
+    image?: boolean;
+    /** Shows the page as a computer set to dark sees it, for sites with dark mode. */
+    dark?: boolean;
+  }): Promise<Uint8Array>;
+}
+//#endregion
+//#region src/screenshots.d.ts
+export declare function localScreenshots(options?: {
+  executablePath?: string;
+}): Screenshotter;
+//#endregion

package/dist/screenshots.js

@@ -0,0 +1,2 @@
+import { t as localScreenshots } from "./screenshots--uulXZYY.js";
+export { localScreenshots };

package/dist/stdio.d.ts

@@ -0,0 +1 @@
+export {}