@abinnovision/payloadcms-mcpx 1.1.0-beta.5 → 2.0.0-beta.7

package/dist/client/capability-matrix.mjs

@@ -1,349 +0,0 @@
-"use client";
-import { CAPABILITIES_FIELD } from "../capabilities.mjs";
-import { CAPABILITY_OPERATIONS, buildToggleActions, capabilityPaths, cellPath, columnState, rowState, toolPath, toolsState } from "../api-keys/capability-matrix.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { CheckboxInput, FieldDescription, FieldLabel, useForm, useFormFields } from "@payloadcms/ui";
-import { useCallback, useMemo } from "react";
-//#region src/client/capability-matrix.tsx
-const NOT_EXPOSED = "The plugin config does not expose this.";
-const BASE_CLASS = "mcpx-capabilities";
-const SHEET = `
-.${BASE_CLASS} tbody tr:hover { background: var(--theme-elevation-50); }
-.${BASE_CLASS}__toggle:hover { text-decoration: underline; }
-.${BASE_CLASS} section:last-of-type { margin-bottom: 0; }
-`;
-const CELL_PADDING = "calc(var(--base) * 0.6)";
-const EDGE_PADDING = "calc(var(--base) * 0.8)";
-/**
-* Payload's own theme variables, so the matrix follows the admin's light and
-* dark themes without shipping a stylesheet consumers would have to transpile.
-* The header block borrows the admin table's treatment: muted, raised a step
-* off the page and closed with a rule.
-*
-* The only literal left is the small-caps section heading, which has no
-* counterpart in the admin to borrow from.
-*/ const styles = {
-	section: { marginBottom: "var(--base)" },
-	table: {
-		tableLayout: "fixed",
-		width: "auto",
-		borderCollapse: "separate",
-		borderSpacing: 0,
-		textAlign: "left"
-	},
-	head: { background: "var(--theme-elevation-50)" },
-	/** The section name, which heads the label column instead of a stray title. */ headTitle: {
-		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
-		verticalAlign: "middle",
-		fontSize: "0.8em",
-		letterSpacing: "0.08em",
-		textTransform: "uppercase",
-		color: "var(--theme-elevation-400)",
-		fontWeight: "normal"
-	},
-	headOperation: {
-		padding: CELL_PADDING,
-		verticalAlign: "middle",
-		color: "var(--theme-elevation-400)",
-		fontWeight: "normal",
-		textAlign: "center",
-		whiteSpace: "nowrap"
-	},
-	headLabel: {
-		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
-		verticalAlign: "middle",
-		color: "var(--theme-elevation-500)",
-		fontWeight: "normal"
-	},
-	/** Closes the header block, across every column rather than the first. */ rule: { borderBottom: "1px solid var(--theme-border-color)" },
-	topStart: { borderStartStartRadius: "var(--style-radius-s)" },
-	topEnd: { borderStartEndRadius: "var(--style-radius-s)" },
-	rowHeader: {
-		padding: `${CELL_PADDING} ${CELL_PADDING} ${CELL_PADDING} ${EDGE_PADDING}`,
-		verticalAlign: "middle",
-		fontWeight: "normal",
-		wordBreak: "break-word"
-	},
-	rowButton: {
-		padding: 0,
-		border: 0,
-		background: "none",
-		color: "inherit",
-		font: "inherit",
-		cursor: "pointer",
-		textAlign: "start",
-		textDecoration: "none"
-	},
-	hint: {
-		display: "block",
-		color: "var(--theme-elevation-400)"
-	},
-	cell: {
-		padding: CELL_PADDING,
-		verticalAlign: "middle",
-		textAlign: "center"
-	},
-	lastCell: { paddingInlineEnd: EDGE_PADDING },
-	dash: {
-		color: "var(--theme-elevation-400)",
-		cursor: "help"
-	}
-};
-/**
-* Payload's own checkbox, which carries the admin's styling and the partial
-* state the column and row toggles need. `name` is what it renders as the
-* input's `title`, so it doubles as the control's accessible name.
-*/ const Box = ({ label, onChange, readOnly, state }) => /*#__PURE__*/ jsx(CheckboxInput, {
-	checked: state === "on",
-	name: label,
-	onToggle: onChange,
-	partialChecked: state === "mixed",
-	readOnly
-});
-/** Both in `--base` multiples, so the columns keep Payload's rhythm. */ const LABEL_WIDTH = "calc(var(--base) * 9)";
-const OPERATION_WIDTH = "calc(var(--base) * 3.5)";
-/** Fixed widths, so every table lines its columns up with the ones above it. */ const Columns = ({ count }) => /*#__PURE__*/ jsxs("colgroup", { children: [/*#__PURE__*/ jsx("col", { style: { width: LABEL_WIDTH } }), Array.from({ length: count }, (_, index) => /*#__PURE__*/ jsx("col", { style: { width: OPERATION_WIDTH } }, index))] });
-/** The rightmost cell carries the table's outer padding, as Payload's does. */ const cellStyle = (isLast) => isLast ? {
-	...styles.cell,
-	...styles.lastCell
-} : styles.cell;
-const Dash = () => /*#__PURE__*/ jsx("span", {
-	"aria-label": NOT_EXPOSED,
-	style: styles.dash,
-	title: NOT_EXPOSED,
-	children: "—"
-});
-/**
-* What an API key may do, as one table per namespace: a row per entity, a
-* column per operation, and a bulk toggle in each column header. The nested
-* checkbox fields this replaces still back every cell, so the stored document
-* is unchanged; only the rendering is.
-*/ const McpxCapabilityMatrix = ({ field, matrix, path = CAPABILITIES_FIELD, readOnly = false, withinTab = false }) => {
-	const { dispatchFields, setModified } = useForm();
-	const paths = useMemo(() => capabilityPaths(matrix, path), [matrix, path]);
-	const encoded = useFormFields(([fields]) => paths.map((cell) => fields[cell]?.value === true ? "1" : "0").join(""));
-	const values = useMemo(() => Object.fromEntries(paths.map((cell, index) => [cell, encoded[index] === "1"])), [paths, encoded]);
-	const toggle = useCallback((intent) => {
-		const actions = buildToggleActions(matrix, path, values, intent);
-		if (actions.length === 0) return;
-		for (const action of actions) dispatchFields(action);
-		setModified(true);
-	}, [
-		matrix,
-		path,
-		values,
-		dispatchFields,
-		setModified
-	]);
-	const namespaces = [{
-		id: "collections",
-		title: "Collections"
-	}, {
-		id: "globals",
-		title: "Globals"
-	}].filter((namespace) => matrix[namespace.id].length > 0);
-	const toolState = toolsState(matrix, path, values);
-	return /*#__PURE__*/ jsxs("div", {
-		className: [
-			"field-type",
-			"group-field",
-			"group-field--top-level",
-			withinTab && "group-field--within-tab",
-			BASE_CLASS
-		].filter(Boolean).join(" "),
-		children: [/*#__PURE__*/ jsx("style", { children: SHEET }), /*#__PURE__*/ jsxs("div", {
-			className: "group-field__wrap",
-			children: [
-				/*#__PURE__*/ jsx("div", {
-					className: "group-field__header",
-					children: /*#__PURE__*/ jsxs("header", { children: [/*#__PURE__*/ jsx("h3", {
-						className: "group-field__title",
-						children: /*#__PURE__*/ jsx(FieldLabel, {
-							as: "span",
-							label: "Capabilities"
-						})
-					}), typeof field?.admin?.description === "string" ? /*#__PURE__*/ jsx(FieldDescription, {
-						description: field.admin.description,
-						path
-					}) : null] })
-				}),
-				namespaces.map((namespace) => {
-					const rows = matrix[namespace.id];
-					const columns = CAPABILITY_OPERATIONS.filter((operation) => rows.some((row) => row[operation.id]));
-					return /*#__PURE__*/ jsx("section", {
-						style: styles.section,
-						children: /*#__PURE__*/ jsxs("table", {
-							style: styles.table,
-							children: [
-								/*#__PURE__*/ jsx(Columns, { count: columns.length }),
-								/*#__PURE__*/ jsxs("thead", {
-									style: styles.head,
-									children: [/*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
-										scope: "col",
-										style: {
-											...styles.headTitle,
-											...styles.topStart
-										},
-										children: namespace.title
-									}), columns.map((operation, column) => /*#__PURE__*/ jsx("th", {
-										scope: "col",
-										style: column === columns.length - 1 ? {
-											...styles.headOperation,
-											...styles.topEnd
-										} : styles.headOperation,
-										title: operation.description,
-										children: operation.label
-									}, operation.id))] }), /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
-										scope: "row",
-										style: {
-											...styles.headLabel,
-											...styles.rule
-										},
-										children: "All"
-									}), columns.map((operation, column) => {
-										const state = columnState(matrix, path, namespace.id, operation.id, values);
-										return /*#__PURE__*/ jsx("td", {
-											style: {
-												...cellStyle(column === columns.length - 1),
-												...styles.rule
-											},
-											children: /*#__PURE__*/ jsx(Box, {
-												label: `${operation.label} every ${namespace.title.toLowerCase()} entry`,
-												onChange: () => {
-													toggle({
-														kind: "column",
-														namespace: namespace.id,
-														operation: operation.id,
-														value: state !== "on"
-													});
-												},
-												readOnly,
-												state
-											})
-										}, operation.id);
-									})] })]
-								}),
-								/*#__PURE__*/ jsx("tbody", { children: rows.map((row) => {
-									const state = rowState(path, namespace.id, row, values);
-									return /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsxs("th", {
-										scope: "row",
-										style: styles.rowHeader,
-										children: [/*#__PURE__*/ jsx("button", {
-											className: `${BASE_CLASS}__toggle`,
-											disabled: readOnly,
-											onClick: () => {
-												toggle({
-													kind: "row",
-													namespace: namespace.id,
-													fieldName: row.fieldName,
-													value: state !== "on"
-												});
-											},
-											style: styles.rowButton,
-											title: `Toggle every capability for ${row.label}`,
-											type: "button",
-											children: row.label
-										}), row.hint ? /*#__PURE__*/ jsx("span", {
-											style: styles.hint,
-											children: row.hint
-										}) : null]
-									}), columns.map((operation, column) => /*#__PURE__*/ jsx("td", {
-										style: cellStyle(column === columns.length - 1),
-										children: row[operation.id] ? /*#__PURE__*/ jsx(Box, {
-											label: `${operation.label} ${row.label}`,
-											onChange: () => {
-												toggle({
-													kind: "cell",
-													namespace: namespace.id,
-													fieldName: row.fieldName,
-													operation: operation.id,
-													value: values[cellPath(path, namespace.id, row.fieldName, operation.id)] !== true
-												});
-											},
-											readOnly,
-											state: values[cellPath(path, namespace.id, row.fieldName, operation.id)] === true ? "on" : "off"
-										}) : /*#__PURE__*/ jsx(Dash, {})
-									}, operation.id))] }, row.fieldName);
-								}) })
-							]
-						})
-					}, namespace.id);
-				}),
-				matrix.tools.length > 0 ? /*#__PURE__*/ jsx("section", {
-					style: styles.section,
-					children: /*#__PURE__*/ jsxs("table", {
-						style: styles.table,
-						children: [
-							/*#__PURE__*/ jsx(Columns, { count: 1 }),
-							/*#__PURE__*/ jsxs("thead", {
-								style: styles.head,
-								children: [/*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
-									scope: "col",
-									style: {
-										...styles.headTitle,
-										...styles.topStart
-									},
-									children: "Tools"
-								}), /*#__PURE__*/ jsx("th", {
-									scope: "col",
-									style: {
-										...styles.headOperation,
-										...styles.topEnd
-									},
-									children: "Enabled"
-								})] }), /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsx("th", {
-									scope: "row",
-									style: {
-										...styles.headLabel,
-										...styles.rule
-									},
-									children: "All"
-								}), /*#__PURE__*/ jsx("td", {
-									style: {
-										...cellStyle(true),
-										...styles.rule
-									},
-									children: /*#__PURE__*/ jsx(Box, {
-										label: "Enable every tool",
-										onChange: () => {
-											toggle({
-												kind: "tools",
-												value: toolState !== "on"
-											});
-										},
-										readOnly,
-										state: toolState
-									})
-								})] })]
-							}),
-							/*#__PURE__*/ jsx("tbody", { children: matrix.tools.map((tool) => /*#__PURE__*/ jsxs("tr", { children: [/*#__PURE__*/ jsxs("th", {
-								scope: "row",
-								style: styles.rowHeader,
-								children: [tool.name, /*#__PURE__*/ jsx("span", {
-									style: styles.hint,
-									children: tool.description
-								})]
-							}), /*#__PURE__*/ jsx("td", {
-								style: cellStyle(true),
-								children: /*#__PURE__*/ jsx(Box, {
-									label: `Enable ${tool.name}`,
-									onChange: () => {
-										toggle({
-											kind: "tool",
-											name: tool.name,
-											value: values[toolPath(path, tool.name)] !== true
-										});
-									},
-									readOnly,
-									state: values[toolPath(path, tool.name)] === true ? "on" : "off"
-								})
-							})] }, tool.name)) })
-						]
-					})
-				}) : null
-			]
-		})]
-	});
-};
-//#endregion
-export { McpxCapabilityMatrix };

package/dist/endpoint/index.mjs

@@ -1,4 +0,0 @@
-import { jsonRpcError, toToolError } from "./errors.mjs";
-import { createMcpServer, isToolEnabled, toolDescription, toolInputSchema } from "./server.mjs";
-import { createMcpxHandler, methodNotAllowed } from "./handler.mjs";
-export { createMcpServer, createMcpxHandler, isToolEnabled, jsonRpcError, methodNotAllowed, toToolError, toolDescription, toolInputSchema };

package/dist/tools/target.mjs

@@ -1,45 +0,0 @@
-import { slugsFor } from "./shared.mjs";
-import { APIError, Forbidden } from "payload";
-//#region src/tools/target.ts
-const refOf = (target) => ({
-	kind: target.kind,
-	slug: target.slug
-});
-/**
-* A raw input shape leaves no top-level `.refine` to express "exactly one of
-* collection and global", so the rule is enforced here, with a message naming
-* the offending arguments.
-*/ const resolveTarget = (scope, args, operation) => {
-	const { collection, global } = args;
-	const allowedSlugs = slugsFor(scope, operation);
-	if (collection !== void 0 && global !== void 0) throw new APIError("Pass either \"collection\" or \"global\", not both.", 400);
-	if (collection === void 0 && global === void 0) throw new APIError("One of \"collection\" or \"global\" is required. Call listCapabilities to see which slugs are available.", 400);
-	if (collection !== void 0) {
-		const found = scope.req.payload.collections[collection];
-		if (!allowedSlugs.collections.includes(collection) || !found) throw new Forbidden(scope.req.t);
-		return {
-			kind: "collection",
-			slug: collection,
-			config: found.config
-		};
-	}
-	const slug = global;
-	const found = scope.req.payload.globals.config.find((candidate) => candidate.slug === slug);
-	if (!allowedSlugs.globals.includes(slug) || !found) throw new Forbidden(scope.req.t);
-	return {
-		kind: "global",
-		slug,
-		config: found
-	};
-};
-/**
-* Checks `id` against the resolved target. A collection document needs one; a
-* global is a singleton and must not carry one. The schema cannot express the
-* dependency, so it is stated here and in every affected tool description.
-*/ const requireIdFor = (target, id) => {
-	if (target.kind === "collection" && id === void 0) throw new APIError(`"id" is required when "collection" is "${target.slug}".`, 400);
-	if (target.kind === "global" && id !== void 0) throw new APIError(`"id" must be omitted when "global" is "${target.slug}"; a global is a singleton.`, 400);
-	return target.kind === "collection" ? id : void 0;
-};
-//#endregion
-export { refOf, requireIdFor, resolveTarget };