@payloadcms/plugin-mcp 4.0.0-internal.a0ef1b8 → 4.0.0-internal.a1317b2

package/src/components/AccessField/index.client.tsx

@@ -1,344 +0,0 @@
-'use client'
-
-import type { JSONFieldClientProps } from 'payload'
-
-import { CheckboxInput, Collapsible, useField } from '@payloadcms/ui'
-import React from 'react'
-
-import type { ClientMCPPluginConfig, MCPAPIKeysDocAccessTree } from '../../types.js'
-
-import './index.css'
-
-const baseClass = 'mcp-access-field'
-
-type ClientItem = ClientMCPPluginConfig['items'][number]
-type ScopeKey = 'collections' | 'globals'
-type FlatKey = 'prompts' | 'resources' | 'tools'
-
-type Props = {
-  pluginConfig: ClientMCPPluginConfig
-} & JSONFieldClientProps
-
-/** Drop a key from an object and return a new object — or `undefined` if it'd be empty. */
-const without = <T extends Record<string, unknown>>(
-  obj: T | undefined,
-  key: string,
-): T | undefined => {
-  if (!obj || !(key in obj)) {
-    return obj
-  }
-  const { [key]: _omitted, ...rest } = obj
-  return Object.keys(rest).length === 0 ? undefined : (rest as T)
-}
-
-const setKey = <T extends Record<string, unknown>>(
-  obj: T | undefined,
-  key: string,
-  value: unknown,
-): T => ({ ...(obj ?? {}), [key]: value }) as T
-
-export const AccessField: React.FC<Props> = ({ path, pluginConfig }) => {
-  const { setValue, value } = useField<MCPAPIKeysDocAccessTree>({ path })
-  const access = value ?? {}
-
-  // Bucket items for rendering. (Bucketing is cheap and runs once per render;
-  // memoizing would mean managing inputs/refs for marginal benefit.)
-  const collectionsBySlug: Record<string, ClientItem[]> = {}
-  const globalsBySlug: Record<string, ClientItem[]> = {}
-  const tools: ClientItem[] = []
-  const prompts: ClientItem[] = []
-  const resources: ClientItem[] = []
-  for (const item of pluginConfig.items) {
-    switch (item.type) {
-      case 'collectionTool':
-        ;(collectionsBySlug[item.collectionSlug!] ??= []).push(item)
-        break
-      case 'globalTool':
-        ;(globalsBySlug[item.globalSlug!] ??= []).push(item)
-        break
-      case 'prompt':
-        prompts.push(item)
-        break
-      case 'resource':
-        resources.push(item)
-        break
-      case 'tool':
-        tools.push(item)
-        break
-    }
-  }
-
-  const isScopedAllowed = (scope: ScopeKey, slug: string, key: string): boolean =>
-    access[scope]?.[slug]?.[key] !== false
-
-  const isFlatAllowed = (scope: FlatKey, key: string): boolean => access[scope]?.[key] !== false
-
-  const toggleScoped = (scope: ScopeKey, slug: string, key: string, allow: boolean) => {
-    if (allow) {
-      const slugBucket = without(access[scope]?.[slug], key)
-      const scopeBucket = slugBucket
-        ? setKey(access[scope], slug, slugBucket)
-        : without(access[scope], slug)
-      setValue(scopeBucket ? setKey(access, scope, scopeBucket) : (without(access, scope) ?? {}))
-    } else {
-      setValue(
-        setKey(
-          access,
-          scope,
-          setKey(access[scope], slug, setKey(access[scope]?.[slug], key, false)),
-        ),
-      )
-    }
-  }
-
-  const toggleFlat = (scope: FlatKey, key: string, allow: boolean) => {
-    if (allow) {
-      const bucket = without(access[scope], key)
-      setValue(bucket ? setKey(access, scope, bucket) : (without(access, scope) ?? {}))
-    } else {
-      setValue(setKey(access, scope, setKey(access[scope], key, false)))
-    }
-  }
-
-  const setAllScoped = (scope: ScopeKey, slug: string, leaves: ClientItem[], allow: boolean) => {
-    if (allow) {
-      const scopeBucket = without(access[scope], slug)
-      setValue(scopeBucket ? setKey(access, scope, scopeBucket) : (without(access, scope) ?? {}))
-    } else {
-      const slugBucket = leaves.reduce<Record<string, boolean>>(
-        (acc, leaf) => ({ ...acc, [leaf.key]: false }),
-        {},
-      )
-      setValue(setKey(access, scope, setKey(access[scope], slug, slugBucket)))
-    }
-  }
-
-  const setAllFlat = (scope: FlatKey, leaves: ClientItem[], allow: boolean) => {
-    if (allow) {
-      setValue(without(access, scope) ?? {})
-    } else {
-      const bucket = leaves.reduce<Record<string, boolean>>(
-        (acc, leaf) => ({ ...acc, [leaf.key]: false }),
-        {},
-      )
-      setValue(setKey(access, scope, bucket))
-    }
-  }
-
-  const collectionSlugs = Object.keys(collectionsBySlug)
-  const globalSlugs = Object.keys(globalsBySlug)
-
-  return (
-    <div className={baseClass}>
-      {collectionSlugs.length > 0 && (
-        <section className={`${baseClass}__section`}>
-          <header className={`${baseClass}__section-header`}>
-            {/* TODO: needs i18n once design is finalized */}
-            <h4>Collection-level permissions</h4>
-            {/* TODO: needs i18n once design is finalized */}
-            <p>Allow MCP clients to perform the following actions within these collections:</p>
-          </header>
-          {collectionSlugs.map((slug) => {
-            const leaves = collectionsBySlug[slug]!
-            return (
-              <Collapsible
-                actions={
-                  <GroupActions
-                    onSetAll={(allow) => setAllScoped('collections', slug, leaves, allow)}
-                  />
-                }
-                className={`${baseClass}__group`}
-                header={<span className={`${baseClass}__group-label`}>{titleCase(slug)}</span>}
-                initCollapsed
-                key={`collection-${slug}`}
-              >
-                <ul className={`${baseClass}__list`}>
-                  {leaves.map((leaf) => (
-                    <li key={leaf.key}>
-                      <CheckboxInput
-                        checked={isScopedAllowed('collections', slug, leaf.key)}
-                        id={`${path}.collections.${slug}.${leaf.key}`}
-                        label={leaf.label}
-                        onToggle={(e) =>
-                          toggleScoped('collections', slug, leaf.key, e.target.checked)
-                        }
-                        tooltip={leaf.description}
-                      />
-                    </li>
-                  ))}
-                </ul>
-              </Collapsible>
-            )
-          })}
-        </section>
-      )}
-
-      {globalSlugs.length > 0 && (
-        <section className={`${baseClass}__section`}>
-          <header className={`${baseClass}__section-header`}>
-            {/* TODO: needs i18n once design is finalized */}
-            <h4>Global-level permissions</h4>
-            {/* TODO: needs i18n once design is finalized */}
-            <p>Allow MCP clients to perform the following actions on these globals:</p>
-          </header>
-          {globalSlugs.map((slug) => {
-            const leaves = globalsBySlug[slug]!
-            return (
-              <Collapsible
-                actions={
-                  <GroupActions
-                    onSetAll={(allow) => setAllScoped('globals', slug, leaves, allow)}
-                  />
-                }
-                className={`${baseClass}__group`}
-                header={<span className={`${baseClass}__group-label`}>{titleCase(slug)}</span>}
-                initCollapsed
-                key={`global-${slug}`}
-              >
-                <ul className={`${baseClass}__list`}>
-                  {leaves.map((leaf) => (
-                    <li key={leaf.key}>
-                      <CheckboxInput
-                        checked={isScopedAllowed('globals', slug, leaf.key)}
-                        id={`${path}.globals.${slug}.${leaf.key}`}
-                        label={leaf.label}
-                        onToggle={(e) => toggleScoped('globals', slug, leaf.key, e.target.checked)}
-                        tooltip={leaf.description}
-                      />
-                    </li>
-                  ))}
-                </ul>
-              </Collapsible>
-            )
-          })}
-        </section>
-      )}
-
-      {(tools.length > 0 || prompts.length > 0 || resources.length > 0) && (
-        <section className={`${baseClass}__section`}>
-          <header className={`${baseClass}__section-header`}>
-            {/* TODO: needs i18n once design is finalized */}
-            <h4>Project-level permissions</h4>
-            {/* TODO: needs i18n once design is finalized */}
-            <p>Cross-cutting tools, prompts, and resources not scoped to a single collection.</p>
-          </header>
-          {tools.length > 0 && (
-            <Collapsible
-              actions={<GroupActions onSetAll={(allow) => setAllFlat('tools', tools, allow)} />}
-              className={`${baseClass}__group`}
-              header={
-                /* TODO: needs i18n once design is finalized */
-                <span className={`${baseClass}__group-label`}>Tools</span>
-              }
-              initCollapsed
-            >
-              <ul className={`${baseClass}__list`}>
-                {tools.map((leaf) => (
-                  <li key={leaf.key}>
-                    <CheckboxInput
-                      checked={isFlatAllowed('tools', leaf.key)}
-                      id={`${path}.tools.${leaf.key}`}
-                      label={leaf.label}
-                      onToggle={(e) => toggleFlat('tools', leaf.key, e.target.checked)}
-                      tooltip={leaf.description}
-                    />
-                  </li>
-                ))}
-              </ul>
-            </Collapsible>
-          )}
-          {prompts.length > 0 && (
-            <Collapsible
-              actions={<GroupActions onSetAll={(allow) => setAllFlat('prompts', prompts, allow)} />}
-              className={`${baseClass}__group`}
-              header={
-                /* TODO: needs i18n once design is finalized */
-                <span className={`${baseClass}__group-label`}>Prompts</span>
-              }
-              initCollapsed
-            >
-              <ul className={`${baseClass}__list`}>
-                {prompts.map((leaf) => (
-                  <li key={leaf.key}>
-                    <CheckboxInput
-                      checked={isFlatAllowed('prompts', leaf.key)}
-                      id={`${path}.prompts.${leaf.key}`}
-                      label={leaf.label}
-                      onToggle={(e) => toggleFlat('prompts', leaf.key, e.target.checked)}
-                      tooltip={leaf.description}
-                    />
-                  </li>
-                ))}
-              </ul>
-            </Collapsible>
-          )}
-          {resources.length > 0 && (
-            <Collapsible
-              actions={
-                <GroupActions onSetAll={(allow) => setAllFlat('resources', resources, allow)} />
-              }
-              className={`${baseClass}__group`}
-              header={
-                /* TODO: needs i18n once design is finalized */
-                <span className={`${baseClass}__group-label`}>Resources</span>
-              }
-              initCollapsed
-            >
-              <ul className={`${baseClass}__list`}>
-                {resources.map((leaf) => (
-                  <li key={leaf.key}>
-                    <CheckboxInput
-                      checked={isFlatAllowed('resources', leaf.key)}
-                      id={`${path}.resources.${leaf.key}`}
-                      label={leaf.label}
-                      onToggle={(e) => toggleFlat('resources', leaf.key, e.target.checked)}
-                      tooltip={leaf.description}
-                    />
-                  </li>
-                ))}
-              </ul>
-            </Collapsible>
-          )}
-        </section>
-      )}
-    </div>
-  )
-}
-
-const GroupActions: React.FC<{ onSetAll: (allow: boolean) => void }> = ({ onSetAll }) => (
-  // TODO: button labels + aria-labels need i18n once design is finalized
-  <div className={`${baseClass}__group-actions`}>
-    <button
-      aria-label="Select all"
-      className={`${baseClass}__action`}
-      onClick={(e) => {
-        e.stopPropagation()
-        onSetAll(true)
-      }}
-      title="Select all"
-      type="button"
-    >
-      all
-    </button>
-    <span aria-hidden className={`${baseClass}__action-sep`}>
-      /
-    </span>
-    <button
-      aria-label="Clear all"
-      className={`${baseClass}__action`}
-      onClick={(e) => {
-        e.stopPropagation()
-        onSetAll(false)
-      }}
-      title="Clear all"
-      type="button"
-    >
-      none
-    </button>
-  </div>
-)
-
-const titleCase = (slug: string): string =>
-  slug.replace(/(^|[-_])(.)/g, (_, sep: string, ch: string) =>
-    sep ? ` ${ch.toUpperCase()}` : ch.toUpperCase(),
-  )

package/src/components/AccessField/index.css

@@ -1,93 +0,0 @@
-@layer payload-default {
-  .mcp-access-field {
-    display: flex;
-    flex-direction: column;
-    gap: var(--base);
-  }
-
-  .mcp-access-field__section {
-    display: flex;
-    flex-direction: column;
-    gap: calc(var(--base) / 2);
-    padding-bottom: var(--base);
-    /* Full-bleed separator: extend past the sidebar's horizontal gutter so the
-       border-block-end spans the entire sidebar width. */
-    margin-inline-start: calc(-1 * var(--sidebar-gutter-h-left, var(--gutter-h)));
-    margin-inline-end: calc(-1 * var(--sidebar-gutter-h-right, var(--gutter-h)));
-    padding-inline-start: var(--sidebar-gutter-h-left, var(--gutter-h));
-    padding-inline-end: var(--sidebar-gutter-h-right, var(--gutter-h));
-    border-block-end: 1px solid var(--theme-elevation-100);
-  }
-
-  .mcp-access-field__section:last-child {
-    border-block-end: none;
-  }
-
-  .mcp-access-field__section-header {
-    display: flex;
-    flex-direction: column;
-  }
-
-  .mcp-access-field__section-header h4 {
-    margin: 0;
-    color: var(--color-text);
-    font-family: var(--text-heading-small-font-family);
-    font-size: var(--text-heading-small-font-size);
-    font-weight: var(--text-heading-small-font-weight);
-    line-height: var(--text-heading-small-line-height);
-    letter-spacing: var(--text-heading-small-letter-spacing);
-  }
-
-  .mcp-access-field__section-header p {
-    margin: 0;
-    color: var(--color-text-secondary);
-    font-family: var(--text-body-medium-font-family);
-    font-size: var(--text-body-medium-font-size);
-    font-weight: var(--text-body-medium-font-weight);
-    line-height: var(--text-body-medium-line-height);
-    letter-spacing: var(--text-body-medium-letter-spacing);
-  }
-
-  .mcp-access-field__group {
-    margin-block-end: calc(var(--base) / 2);
-  }
-
-  .mcp-access-field__group-label {
-    font-weight: 600;
-  }
-
-  .mcp-access-field__group-actions {
-    display: flex;
-    align-items: center;
-    gap: calc(var(--base) / 6);
-  }
-
-  .mcp-access-field__action {
-    appearance: none;
-    background: none;
-    border: none;
-    color: var(--theme-elevation-500);
-    cursor: pointer;
-    font-size: 0.75rem;
-    padding: 0;
-  }
-
-  .mcp-access-field__action:hover {
-    color: var(--theme-text);
-    text-decoration: underline;
-  }
-
-  .mcp-access-field__action-sep {
-    color: var(--theme-elevation-300);
-    font-size: 0.75rem;
-  }
-
-  .mcp-access-field__list {
-    list-style: none;
-    margin: 0;
-    padding: 0;
-    display: flex;
-    flex-direction: column;
-    gap: calc(var(--base) / 3);
-  }
-}

package/src/utils/getVirtualFieldNames.ts

@@ -1,53 +0,0 @@
-import type { SanitizedConfig } from 'payload'
-
-import { fieldIsVirtual } from 'payload/shared'
-
-/**
- * Returns the names of all top-level virtual fields for a given collection slug.
- */
-export function getCollectionVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  const collection = config.collections.find((c) => c.slug === slug)
-
-  if (!collection) {
-    return []
-  }
-
-  return collection.flattenedFields
-    .filter((field) => 'name' in field && fieldIsVirtual(field))
-    .map((field) => (field as { name: string }).name)
-}
-
-/**
- * Returns the names of all top-level virtual fields for a given global slug.
- */
-export function getGlobalVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  const global = config.globals.find((g) => g.slug === slug)
-
-  if (!global) {
-    return []
-  }
-
-  return global.flattenedFields
-    .filter((field) => 'name' in field && fieldIsVirtual(field))
-    .map((field) => (field as { name: string }).name)
-}
-
-/**
- * Strips virtual field values from a data object given a list of virtual field names.
- */
-export function stripVirtualFields(
-  data: Record<string, unknown>,
-  virtualFieldNames: string[],
-): Record<string, unknown> {
-  if (virtualFieldNames.length === 0) {
-    return data
-  }
-
-  const stripped = { ...data }
-
-  for (const name of virtualFieldNames) {
-    delete stripped[name]
-  }
-
-  return stripped
-}

package/src/utils/localAPIDefaults.ts

@@ -1,22 +0,0 @@
-import type { AuthorizedMCP } from '../types.js'
-
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */
-export const localAPIDefaults = (
-  authorizedMCP: AuthorizedMCP,
-): { overrideAccess: boolean; user: AuthorizedMCP['user'] } => ({
-  overrideAccess: authorizedMCP.overrideAccess,
-  user: authorizedMCP.user,
-})

package/src/utils/schemaConversion/buildToolInput.ts

@@ -1,68 +0,0 @@
-import type { StandardSchemaWithJSON } from '@modelcontextprotocol/server'
-
-import { z } from 'zod'
-
-import type { JsonSchemaType } from '../../types.js'
-
-/**
- * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like
- * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated
- * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).
- * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.
- *
- * @example
- * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a
- * reused def is duplicated at every use:
- * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`
- *
- * @example
- * Lossier - zod drops the `description` on `enum`/`const` fields:
- * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`
- */
-export const buildToolInput = <TControls extends z.ZodRawShape>({
-  controls,
-  dataDescription,
-  dataSchema,
-}: {
-  /** Tool options alongside `data` (depth, draft, where, …) as plain zod - inferred into `input`. */
-  controls: TControls
-  dataDescription: string
-  dataSchema: JsonSchemaType
-}) => {
-  // `sanitizeEntitySchema` already emits draft 2020-12 with `$defs`, which is what zod's `fromJSONSchema`
-  // and MCP clients both expect. Drop only the root `$schema` keyword, redundant once it's a sub-schema.
-  const { $schema: _schema, ...entitySchema } = dataSchema as Record<string, unknown>
-
-  const schema = z.object({
-    data: z.fromJSONSchema(entitySchema as unknown as z.core.JSONSchema.JSONSchema),
-    ...controls,
-  })
-  const standard = (schema as unknown as StandardSchemaWithJSON)['~standard']
-
-  return {
-    '~standard': {
-      ...standard,
-      jsonSchema: {
-        ...standard.jsonSchema,
-        input: (options) => {
-          // Start from zod's JSON Schema for the whole input, then replace its lossy `data` schema with
-          // the sanitized entity schema. The entity's `$defs` move to the root so the `$ref`s resolve.
-          const generated = standard.jsonSchema.input(options)
-          const { $defs, ...entityBody } = entitySchema
-          ;(generated.properties as Record<string, unknown>).data = {
-            ...entityBody,
-            description: dataDescription,
-          }
-          if ($defs) {
-            generated.$defs = $defs as object
-          } else {
-            delete generated.$defs
-          }
-          return generated
-        },
-      },
-    },
-  } as StandardSchemaWithJSON<
-    { data: Record<string, unknown> } & Omit<z.output<typeof schema>, 'data'>
-  >
-}

package/src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts

@@ -1,27 +0,0 @@
-import type { JsonSchemaType } from '../../types.js'
-
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */
-export function removeVirtualFieldsFromSchema(
-  schema: JsonSchemaType,
-  virtualFieldNames: string[],
-): JsonSchemaType {
-  if (virtualFieldNames.length === 0) {
-    return schema
-  }
-
-  for (const name of virtualFieldNames) {
-    delete schema?.properties?.[name]
-  }
-
-  if (Array.isArray(schema.required)) {
-    schema.required = schema.required.filter((field) => !virtualFieldNames.includes(field))
-    if (schema.required.length === 0) {
-      delete schema.required
-    }
-  }
-
-  return schema
-}