@abinnovision/payloadcms-mcpx 1.1.0-beta.6 → 2.0.0-beta.12

package/dist/types.d.mts

@@ -1,3 +1,4 @@
+import { DocumentId } from "./entity.mjs";
 import { CollectionConfig, CollectionSlug, GlobalSlug, PayloadRequest, TypedUser } from "payload";
 import { z } from "zod";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
@@ -17,63 +18,101 @@ declare module "payload" {
  * - `false`: no write tool touches it.
  * - `"draft"`: writes land as drafts and nothing MCP does changes what the
  *   public sees. Requires `versions.drafts`.
- * - `"live"`: MCP may change live content. On an entity with drafts that means
- *   `publishDocument` is exposed; on one without, where there is no draft to
- *   land on, it means the write itself is permitted and lands live.
+ * - `"live"`: MCP may change live content. On an entity with drafts that
+ *   exposes `publishDocument`. On one without, there is no draft, so the write
+ *   itself is permitted and lands live.
  */
 export type McpxWriteMode = "draft" | "live" | false;
-/** A key can only enable what the config exposes here. */
+/**
+ * What an entity exposes. The config names the entities that are reachable and
+ * only takes capabilities away; a key's checkboxes decide per key. `true` is
+ * shorthand for `{}`, which exposes everything the entity supports.
+ */
 export interface McpxCollectionOptions {
-  /** Expose `describeSchema`, `findDocuments`, `getDocument`. Default `true`. */
-  read?: boolean;
   /**
-   * Expose `patchDocument`, `validateDocument` and, unless this is an upload
-   * collection, `createDocument`, and how far those writes reach. Default
-   * `false`.
+   * Expose `describeSchema`, `findDocuments`, `getDocument`. Default `true`.
    */
-  write?: McpxWriteMode;
-}
-/** A singleton, so neither `findDocuments` nor `createDocument` reaches one. */
-export interface McpxGlobalOptions {
-  /** Expose `describeSchema` and `getDocument`. Default `true`. */
   read?: boolean;
   /**
-   * Expose `patchDocument` and `validateDocument`, and how far those writes
-   * reach. Default `false`.
+   * Expose `patchDocument`, `validateDocument` and `createDocument`. An upload
+   * collection is created in only where MCP accepts its files. Without drafts
+   * a write changes live content. Default `true`.
+   */
+  write?: boolean;
+  /**
+   * Expose `publishDocument`, which promotes a draft to live content. Needs
+   * `versions.drafts` and `write`. Default `true` where the entity has drafts.
+   * `false` keeps writes as drafts and is refused where there are none.
    */
-  write?: McpxWriteMode;
+  publish?: boolean;
 }
+/**
+ * The same options. A singleton, so neither `findDocuments` nor
+ * `createDocument` reaches one.
+ */
+export type McpxGlobalOptions = McpxCollectionOptions;
 export type McpxToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
-/** What the config exposes, before an API key's checkboxes narrow it. */
+/**
+ * What the config exposes, before an API key's checkboxes narrow it.
+ */
 export interface McpxExposedEntity {
   slug: string;
   read: boolean;
   write: McpxWriteMode;
   hasDrafts: boolean;
-  /** Payload keeps a version history, with or without drafts. */
+  /**
+   * The entity has Payload `versions`, with or without drafts, and is
+   * readable. Says nothing about drafts; see `hasDrafts`.
+   */
   hasVersions: boolean;
-  /** An upload document is a file, and no tool here can supply one. */
+  /**
+   * An upload document is a file, which only an upload grant can supply.
+   */
   isUpload: boolean;
-  /** Name of the capability group on the key document. */
+  /**
+   * Name of the capability group on the key document.
+   */
   fieldName: string;
 }
-/** What a tool knows about the current request. */
-export interface McpxToolScope {
-  req: PayloadRequest;
-  capabilities: McpxResolvedCapabilities;
+/**
+ * The slugs a key may read, write and publish.
+ */
+export interface McpxScopeSlugs {
   readable: string[];
   writable: string[];
   publishable: string[];
-  readableGlobals: string[];
-  writableGlobals: string[];
-  publishableGlobals: string[];
-  /** `null` when localization is off. */
-  locales: null | string[];
-  defaultLocale: null | string;
+}
+/**
+ * What a tool knows about the current request.
+ */
+export interface McpxToolScope {
+  req: PayloadRequest;
+  capabilities: McpxResolvedCapabilities;
+  collections: McpxScopeSlugs;
+  globals: McpxScopeSlugs;
+  /**
+   * `null` when localization is off.
+   */
+  localization: null | {
+    locales: string[];
+    defaultLocale: string;
+  };
   limits: {
     maxLimit: number;
     maxDepth: number;
   };
+  /**
+   * Whether files can be uploaded at all: the KV is database-backed and no
+   * custom `auth.resolve` is configured.
+   */
+  uploads: boolean;
+  /**
+   * `null` when `diagnostics` is off.
+   */
+  diagnostics: null | {
+    name: string;
+    version: string;
+  };
   exposure: {
     collections: McpxExposedEntity[];
     globals: McpxExposedEntity[];
@@ -85,9 +124,13 @@ export interface McpxToolScope {
  * per request, leaving no static shape to infer from.
  */
 export interface McpxTool<Shape extends z.ZodRawShape = z.ZodRawShape, Args = z.infer<z.ZodObject<Shape>>> {
-  /** camelCase, unique, not one of the builtin tool names. */
+  /**
+   * camelCase, unique, not one of the builtin tool names.
+   */
   name: string;
-  /** Built per request so it can state what this key's writes actually do. */
+  /**
+   * Built per request so it can state what this key's writes do.
+   */
   description: string | ((scope: McpxToolScope) => string);
   annotations?: ToolAnnotations;
   /**
@@ -99,39 +142,32 @@ export interface McpxTool<Shape extends z.ZodRawShape = z.ZodRawShape, Args = z.
   /**
    * Built per request so enums can be narrowed to what the key may touch.
    * Registered strictly either way: an unknown argument is rejected by name
-   * rather than stripped.
+   * instead of stripped.
    */
   inputSchema?: Shape | ((scope: McpxToolScope) => z.ZodRawShape);
   handler(ctx: {
     args: Args;
     scope: McpxToolScope;
-    /** Shorthand for `scope.req`. */
+    /**
+     * Shorthand for `scope.req`.
+     */
     req: PayloadRequest;
     extra: McpxToolExtra;
   }): CallToolResult | Promise<CallToolResult>;
 }
-/** Argument type erased, so a registry can hold tools of differing shapes. */
-export type McpxAnyTool = McpxTool<z.ZodRawShape, never>;
-/** Fixed shape; arguments inferred from it. */
-export declare function defineMcpxTool<Shape extends z.ZodRawShape>(tool: McpxTool<Shape> & {
-  inputSchema?: Shape;
-}): McpxTool<Shape>;
-/** Per-request shape returned as an object literal; arguments inferred from it. */
-export declare function defineMcpxTool<Shape extends z.ZodRawShape>(tool: McpxTool<Shape> & {
-  inputSchema: (scope: McpxToolScope) => Shape;
-}): McpxAnyTool;
 /**
- * Per-request shape built from helpers that erase to `z.ZodRawShape`, as the
- * builtins do. Nothing to infer from, so state the arguments instead.
+ * Argument type erased, so a registry can hold tools of differing shapes.
  */
-export declare function defineMcpxTool<Args>(tool: McpxTool<z.ZodRawShape, Args> & {
-  inputSchema: (scope: McpxToolScope) => z.ZodRawShape;
-}): McpxAnyTool;
+export type McpxAnyTool = McpxTool<z.ZodRawShape, never>;
 export interface McpxAuthResult {
-  /** Must carry `collection`. */
+  /**
+   * Must carry `collection`.
+   */
   user: TypedUser;
-  apiKeyId: number | string;
-  /** The `capabilities` group as stored on the key document. */
+  apiKeyId: DocumentId;
+  /**
+   * The `capabilities` group as stored on the key document.
+   */
   capabilities: unknown;
 }
 /**
@@ -141,36 +177,56 @@ export interface McpxAuthResult {
  * to `Record<string, unknown>`, which interfaces do not satisfy.
  */
 export type McpxPluginOptions = {
-  /** Allow-list of collections. `true` is shorthand for `{ read: true }`. */
+  /**
+   * Allow-list of collections. `true` is shorthand for `{}`.
+   */
   collections: Partial<Record<CollectionSlug, McpxCollectionOptions | true>>;
-  /** Allow-list of globals. `true` is shorthand for `{ read: true }`. */
+  /**
+   * Allow-list of globals. `true` is shorthand for `{}`.
+   */
   globals?: Partial<Record<GlobalSlug, McpxGlobalOptions | true>>;
-  /** Collection the keys act as. Default `config.admin.user`, then `users`. */
+  /**
+   * Collection the keys act as. Default `config.admin.user`, then `users`.
+   */
   userCollection?: CollectionSlug;
   apiKeys?: {
-    /** Slug of the generated API key collection. Default `mcpx-api-keys`. */
+    /**
+     * Slug of the generated API key collection. Default `mcpx-api-keys`.
+     */
     slug?: string;
     /**
      * Add a "Connect a client" tab to saved keys, holding ready-to-paste MCP
      * client config. Default `true`. The snippets contain the key in full.
      */
     setupGuide?: boolean;
-    /** Final override applied to the generated collection. */
+    /**
+     * Final override applied to the generated collection.
+     */
     overrideCollection?: (collection: CollectionConfig) => CollectionConfig;
   };
   endpoint?: {
-    /** Endpoint path below the API route. Default `/mcpx`. */
+    /**
+     * Endpoint path below the API route. Default `/mcpx`.
+     */
     path?: string;
   };
   limits?: {
-    /** Upper bound for `findDocuments.limit`. Default 25. */
+    /**
+     * Upper bound for `findDocuments.limit`. Default 25.
+     */
     maxLimit?: number;
-    /** Upper bound for `depth` on reads. Default 1. */
+    /**
+     * Upper bound for `depth` on reads. Default 1.
+     */
     maxDepth?: number;
   };
   tools?: McpxAnyTool[];
   auth?: {
-    /** Replace or wrap the default key resolution. Return `null` for 401. */
+    /**
+     * Replace or wrap the default key resolution. Return `null` for 401. A
+     * result whose user has no `id` or whose `collection` is not the user
+     * collection, or that has no `apiKeyId`, is also answered with 401.
+     */
     resolve?: (args: {
       req: PayloadRequest;
       resolveDefault: () => Promise<McpxAuthResult | null>;
@@ -180,31 +236,35 @@ export type McpxPluginOptions = {
     name?: string;
     version?: string;
   };
+  /**
+   * Expose the server version plus repository and issue links to clients. Default `true`.
+   */
+  diagnostics?: boolean;
 };
-/** What a key may do with one entity. Globals reuse this shape. */
+/**
+ * What a key may do with one entity. Globals reuse this shape.
+ */
 export interface McpxCollectionCapabilities {
   read: boolean;
   write: boolean;
-  /** Only ever true where the config sets `write: "live"` and drafts exist. */
+  /**
+   * Only ever true where the config lets writes publish and drafts exist.
+   */
   publish: boolean;
 }
-/** In force for one request: plugin config AND key checkboxes. */
+/**
+ * In force for one request: the plugin config and the key checkboxes together.
+ */
 export interface McpxResolvedCapabilities {
   collections: Record<string, McpxCollectionCapabilities>;
   globals: Record<string, McpxCollectionCapabilities>;
   tools: Record<string, boolean>;
 }
-/** Stamped on `req.context.mcpx`; see {@link isMcpxRequest}. */
+/**
+ * Stamped on `req.context.mcpx`; see {@link isMcpxRequest}.
+ */
 export interface McpxRequestContext {
-  apiKeyId: number | string;
+  apiKeyId: DocumentId;
   capabilities: McpxResolvedCapabilities;
 }
-/** One reason a human could not publish the draft as it stands. */
-export interface PublishBlocker {
-  /** Resolved field label path, e.g. "Layout > Block 2 (Hero) > Title". */
-  field?: string;
-  message: string;
-  /** JSON Pointer to the offending value, e.g. "/layout/2/title". */
-  path: string;
-}
 //#endregion

package/dist/upload/file.mjs

@@ -0,0 +1,166 @@
+import { errorResult, jsonResult } from "../result.mjs";
+import { issueGrant, uploadKvSlug } from "./grant.mjs";
+import { collectPublishBlockers } from "../write/publish-blockers.mjs";
+import { APIError } from "payload";
+import { hasDraftValidationEnabled, hasDraftsEnabled, validateMimeType } from "payload/shared";
+import { z } from "zod";
+//#region src/upload/file.ts
+const MAX_BYTES = 26214400;
+const FILENAME = /^[^/\\\p{Cc}]+$/u;
+const MIME_TYPE = /^[\w.+-]+\/[\w.+-]+$/;
+const uploadedFiles = /* @__PURE__ */ new WeakMap();
+const fileSchema = (maxBytes) => z.strictObject({
+	filename: z.string().max(255).regex(FILENAME),
+	mimeType: z.string().max(255).regex(MIME_TYPE),
+	size: z.number().int().min(1).max(maxBytes)
+});
+/**
+* The largest file accepted: Payload's `upload.limits.fileSize` if set, and
+* never more than 25 MB, since the body is buffered.
+*/ const uploadMaxBytes = (config) => Math.min(config.upload.limits?.fileSize ?? MAX_BYTES, MAX_BYTES);
+const allowedMimeTypes = (scope, slug) => {
+	if (!scope.uploads || !scope.collections.writable.includes(slug)) return [];
+	const entity = scope.exposure.collections.find((candidate) => candidate.slug === slug);
+	const config = scope.req.payload.config.collections.find((candidate) => candidate.slug === slug);
+	return entity?.isUpload === true && Array.isArray(config?.upload.mimeTypes) ? config.upload.mimeTypes : [];
+};
+/**
+* Whether this key may send a file to `slug`: a writable upload collection
+* that sets `upload.mimeTypes`.
+*/ const acceptsFiles = (scope, slug) => allowedMimeTypes(scope, slug).length > 0;
+/**
+* The collections this key may send files to.
+*/ const fileSlugs = (scope) => scope.collections.writable.filter((slug) => acceptsFiles(scope, slug));
+/**
+* The `file` argument, present only when the key may send a file somewhere.
+*/ const fileShape = (scope, description) => {
+	const slugs = fileSlugs(scope);
+	return slugs.length === 0 ? {} : { file: fileSchema(uploadMaxBytes(scope.req.payload.config)).optional().describe(description(slugs.join(", "))) };
+};
+/**
+* Throws for a `file` sent to an entity that does not accept one, or declared
+* with a type outside its `upload.mimeTypes`. Payload stores the declared
+* type, so it is held to the same list as the content.
+*/ const assertAcceptsFile = (scope, target, file) => {
+	const mimeTypes = target.kind === "global" ? [] : allowedMimeTypes(scope, target.slug);
+	if (mimeTypes.length === 0) throw new APIError(`"${target.slug}" does not accept files through MCP: it is not an upload collection, or it sets no upload.mimeTypes.`, 400);
+	if (!validateMimeType(file.mimeType, mimeTypes)) throw new APIError(`"${target.slug}" accepts only ${mimeTypes.join(", ")}, not "${file.mimeType}".`, 400);
+};
+/**
+* Attaches the claimed bytes to the request the tool runs on.
+*/ const setUploadedFile = (req, file) => {
+	uploadedFiles.set(req, file);
+};
+/**
+* The bytes for this call, or `undefined` before they were sent.
+*/ const uploadedFile = (req) => uploadedFiles.get(req);
+const sharesPublishedFile = async (req, entity, id) => {
+	if (!hasDraftsEnabled(entity.config)) return false;
+	const read = {
+		collection: entity.slug,
+		id,
+		depth: 0,
+		overrideAccess: true,
+		disableErrors: true,
+		select: {
+			filename: true,
+			_status: true
+		},
+		req
+	};
+	const [latest, published] = await Promise.all([req.payload.findByID({
+		...read,
+		draft: true
+	}), req.payload.findByID({
+		...read,
+		draft: false
+	})]);
+	return latest?.["_status"] === "draft" && published?.["_status"] === "published" && latest["filename"] === published["filename"];
+};
+/**
+* Refuses a file write Payload would turn into data loss: a replace that
+* deletes the published file, or a write that fails validation after the old
+* file is gone. Payload validates only after it moves files, so the merged
+* data is validated here first wherever Payload will validate it.
+*/ const fileWriteRefusal = async (scope, target) => {
+	const { entity, id } = target;
+	if (id !== void 0 && await sharesPublishedFile(scope.req, entity, id)) return errorResult("The file was not replaced: the latest draft still uses the published file, which the replace would delete. Publish or discard the draft first.");
+	if (hasDraftsEnabled(entity.config) && !hasDraftValidationEnabled(entity.config)) return;
+	const { blockers } = await collectPublishBlockers(scope.req, {
+		doc: {
+			...target.data,
+			...id === void 0 ? {} : { id }
+		},
+		entity
+	});
+	return blockers.length === 0 ? void 0 : errorResult("Nothing was written: the document fails validation.", { validationErrors: blockers });
+};
+const handoffUrl = (req, path) => {
+	const request = new URL(req.url ?? "");
+	const url = new URL(req.payload.config.serverURL || request.origin);
+	url.pathname = `${request.pathname.replace(/\/+$/, "")}/${path}`;
+	return url.toString();
+};
+const grantContext = (req) => {
+	const slug = uploadKvSlug(req.payload.config);
+	const apiKeyId = req.context.mcpx?.apiKeyId;
+	if (slug === void 0 || apiKeyId === void 0) throw new Error("A handoff was offered without a database KV or key.");
+	return {
+		slug,
+		apiKeyId
+	};
+};
+/**
+* Stores the call as a grant and returns where to PUT its file. Nothing else
+* is written: the PUT runs the same call again with the bytes attached.
+*/ const uploadHandoff = async (scope, call) => {
+	const { req } = scope;
+	const { payload } = req;
+	const { slug, apiKeyId } = grantContext(req);
+	const url = handoffUrl(req, "upload");
+	const { grantId, exp } = await issueGrant(payload, slug, {
+		kind: "upload",
+		apiKeyId,
+		tool: call.tool,
+		args: call.args,
+		locale: req.locale ?? null,
+		fallbackLocale: req.fallbackLocale ?? null
+	});
+	return jsonResult({ upload: {
+		url,
+		method: "PUT",
+		headers: {
+			"content-type": call.args.file.mimeType,
+			"x-mcpx-grant": grantId
+		},
+		expiresAt: new Date(exp).toISOString(),
+		maxBytes: uploadMaxBytes(payload.config)
+	} });
+};
+/**
+* The upload collections whose files this key may download. A collection
+* with its own top-level `download` field is left out, since the handoff
+* would overwrite it in the result.
+*/ const downloadSlugs = (scope) => scope.uploads ? scope.collections.readable.filter((slug) => scope.exposure.collections.find((candidate) => candidate.slug === slug)?.isUpload === true && !scope.req.payload.collections[slug]?.config.flattenedFields.some((field) => field.name === "download")) : [];
+/**
+* Stores a grant for the file of a document just read and returns where to
+* GET it.
+*/ const downloadHandoff = async (scope, target) => {
+	const { req } = scope;
+	const { slug, apiKeyId } = grantContext(req);
+	const url = handoffUrl(req, "file");
+	const { grantId, exp } = await issueGrant(req.payload, slug, {
+		kind: "download",
+		apiKeyId,
+		...target,
+		fallbackLocale: req.fallbackLocale ?? null
+	});
+	return {
+		url,
+		method: "GET",
+		headers: { "x-mcpx-grant": grantId },
+		expiresAt: new Date(exp).toISOString()
+	};
+};
+//#endregion
+export { acceptsFiles, assertAcceptsFile, downloadHandoff, downloadSlugs, fileShape, fileSlugs, fileWriteRefusal, setUploadedFile, uploadHandoff, uploadMaxBytes, uploadedFile };

package/dist/upload/grant.mjs

@@ -0,0 +1,96 @@
+import { isPlainObject } from "../guards.mjs";
+import { hashApiKey } from "../api-keys/key.mjs";
+import { APIError, ValidationError } from "payload";
+import crypto from "node:crypto";
+//#region src/upload/grant.ts
+const GRANT_TTL_MS = 3e5;
+const GRANTS_PER_KEY = 10;
+const GRANT_ID = /^[\w-]{43}$/;
+const NO_REQ = {};
+const grantPrefix = (apiKeyId) => `mcpx-grant:${String(apiKeyId)}:`;
+const usedPrefix = (apiKeyId) => `mcpx-grant-used:${String(apiKeyId)}:`;
+const expOf = (data) => isPlainObject(data) && typeof data["exp"] === "number" ? data["exp"] : 0;
+/**
+* The KV collection slug, when Payload's database KV adapter backs it with a
+* unique `key`, which the single-use claim relies on. `undefined` otherwise.
+*/ const uploadKvSlug = (config) => {
+	const kv = config.kv;
+	const key = kv?.kvCollection?.fields.find((field) => "name" in field && field.name === "key");
+	return key && "unique" in key && key.unique ? kv?.kvCollection?.slug : void 0;
+};
+const findRows = async (payload, slug, fragments) => {
+	const { docs } = await payload.db.find({
+		collection: slug,
+		where: { or: fragments.map((fragment) => ({ key: { like: fragment } })) },
+		limit: 0,
+		pagination: false,
+		req: NO_REQ
+	});
+	return docs;
+};
+/**
+* Stores a grant and returns its id, the only copy of which goes to the
+* client. The row key holds the HMAC of the id. Expired rows of the same key
+* are purged first, and a key may hold at most {@link GRANTS_PER_KEY} grants.
+*/ const issueGrant = async (payload, slug, grant) => {
+	const now = Date.now();
+	const prefixes = [grantPrefix(grant.apiKeyId), usedPrefix(grant.apiKeyId)];
+	const rows = (await findRows(payload, slug, prefixes)).filter((row) => prefixes.some((prefix) => row.key.startsWith(prefix)));
+	const expired = rows.filter((row) => expOf(row.data) <= now);
+	if (expired.length > 0) await payload.db.deleteMany({
+		collection: slug,
+		where: { key: { in: expired.map((row) => row.key) } },
+		req: NO_REQ
+	});
+	if (rows.filter((row) => row.key.startsWith(prefixes[0]) && expOf(row.data) > now).length >= GRANTS_PER_KEY) throw new APIError(`This key already has ${String(GRANTS_PER_KEY)} uploads or downloads waiting. Use or abandon them first; each expires 5 minutes after it was issued.`, 429);
+	const grantId = crypto.randomBytes(32).toString("base64url");
+	const exp = now + GRANT_TTL_MS;
+	await payload.db.create({
+		collection: slug,
+		data: {
+			key: `${grantPrefix(grant.apiKeyId)}${hashApiKey(payload.secret, grantId)}`,
+			data: {
+				...grant,
+				exp
+			}
+		},
+		req: NO_REQ
+	});
+	return {
+		grantId,
+		exp
+	};
+};
+/**
+* Loads the grant for `grantId` and marks it used, or returns `undefined` for
+* a malformed, unknown, expired or used one. The marker is a unique-key
+* insert, so of two concurrent claims exactly one succeeds. A malformed id
+* is refused before any database read.
+*/ const claimGrant = async (payload, slug, grantId) => {
+	if (!GRANT_ID.test(grantId)) return;
+	const hash = hashApiKey(payload.secret, grantId);
+	const row = (await findRows(payload, slug, [hash])).find((candidate) => candidate.key.startsWith("mcpx-grant:") && candidate.key.endsWith(`:${hash}`));
+	const grant = row?.data;
+	if (!row || !isPlainObject(grant) || row.key !== `${grantPrefix(grant.apiKeyId)}${hash}` || expOf(grant) <= Date.now()) return;
+	try {
+		await payload.db.create({
+			collection: slug,
+			data: {
+				key: `${usedPrefix(grant.apiKeyId)}${hash}`,
+				data: { exp: grant.exp }
+			},
+			req: NO_REQ
+		});
+	} catch (error) {
+		if (error instanceof ValidationError) return;
+		throw error;
+	}
+	await payload.db.deleteOne({
+		collection: slug,
+		where: { key: { equals: row.key } },
+		req: NO_REQ
+	});
+	return grant;
+};
+//#endregion
+export { claimGrant, issueGrant, uploadKvSlug };

package/dist/version.mjs

@@ -2,5 +2,7 @@
 /**
 * Package version injected at build time; sources under Vitest report "dev".
 */ const MCPX_VERSION = "1.0.0";
+const MCPX_REPOSITORY_URL = "https://github.com/abinnovision/payloadcms-commons/tree/main/packages/mcpx";
+const MCPX_ISSUES_URL = "https://github.com/abinnovision/payloadcms-commons/issues";
 //#endregion
-export { MCPX_VERSION };
+export { MCPX_ISSUES_URL, MCPX_REPOSITORY_URL, MCPX_VERSION };