@strapi/upload 5.53.0 → 5.54.0

package/dist/server/src/index.d.ts

@@ -321,6 +321,12 @@ declare const _default: () => {
             replace: (id: string | number, { data, file }: {
                 data: {
                     fileInfo: import("./types").FileInfo;
+                } & {
+                    refId?: string | number;
+                    ref?: string;
+                    field?: string;
+                    path?: string;
+                    tmpWorkingDirectory?: string;
                 };
                 file: import("./types").InputFile;
             }, opts?: {
@@ -367,14 +373,14 @@ declare const _default: () => {
                 };
             }) => Promise<any>;
             exists: (params?: {}) => Promise<boolean>;
-            deleteByIds: (ids?: never[]) => Promise<{
+            deleteByIds: (ids?: number[]) => Promise<{
                 folders: any[];
                 totalFolderNumber: number;
                 totalFileNumber: number;
             }>;
             update: (id: number, { name, parent, }: {
                 name: string;
-                parent: number | null;
+                parent?: number | null;
             }, { user }: {
                 user: {
                     id: string | number;

package/dist/server/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;gCAKxC,CAAC;oCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAW00G,CAAC;mBAAe,CAAC;qBAAqB,CAAC;oBAAoB,CAAC;mCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT/8G,wBAQG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;gCAKxC,CAAC;oCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAW00G,CAAC;mBAAe,CAAC;qBAAqB,CAAC;oBAAoB,CAAC;mCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAv1B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AATznF,wBAQG"}

package/dist/server/src/mcp/ambient-instance.d.ts

@@ -0,0 +1,65 @@
+import type { Core } from '@strapi/types';
+/**
+ * Asserts that an MCP handler's Strapi instance is the ambient `global.strapi`.
+ *
+ * Two of the upload plugin's services — `folder` and `file` — are registered as plain object
+ * literals rather than factories (see `services/index.ts`), so their methods close over the
+ * module-scope ambient `strapi` and query `global.strapi.db` regardless of which instance is
+ * passed to `getService`. Passing an instance therefore selects the right plugin registry but
+ * does *not* bind the queries to it.
+ *
+ * The folder tools reach `folder` directly. The asset write tools reach `file` transitively:
+ * `upload.updateFileInfo` resolves it with a bare `getService('file')` (`services/upload.ts`),
+ * and `file.getFolderPath` then queries the ambient `strapi.db`. So a handler that looks
+ * instance-bound can still mix ambient reads with instance-bound writes.
+ *
+ * Threading an instance through both services is a broader refactor than the MCP surface should
+ * carry: `create`, `update` and `deleteByIds` reach for `strapi.db`, `strapi.eventHub` and
+ * `strapi.getModel`, `update` runs a multi-statement transaction, and every admin controller and
+ * validator already depends on the ambient form.
+ *
+ * So the dependency is made explicit and asserted instead. Handlers call this in their factory
+ * body — at handler construction, not per call — so a mismatch fails while the tool is being
+ * registered rather than surfacing to an agent as tool output mid-conversation.
+ *
+ * A single-app server is unaffected: `createStrapi` assigns its instance to `global.strapi`, so
+ * the two agree. If they ever diverge — a second Strapi instance in one process — this throws
+ * rather than silently reading or writing the wrong app's media library.
+ */
+export declare const assertAmbientInstance: (strapi: Core.Strapi) => void;
+/**
+ * Resolves the `folder` service for an MCP handler.
+ *
+ * A bare `getService('folder', strapi)` reads as instance-bound but is not — see
+ * `assertAmbientInstance` for why. Handlers assert the instance once at construction; this keeps
+ * the resolution behind a named helper so the call sites do not reintroduce the misleading form.
+ */
+export declare const getFolderService: (strapi: Core.Strapi) => {
+    create: (folderData: Pick<import("../types").Folder, "name" | "parent">, opts?: {
+        user: {
+            id: string | number;
+        };
+    }) => Promise<any>;
+    exists: (params?: {}) => Promise<boolean>;
+    deleteByIds: (ids?: number[]) => Promise<{
+        folders: any[];
+        totalFolderNumber: number;
+        totalFileNumber: number;
+    }>;
+    update: (id: number, { name, parent, }: {
+        name: string;
+        parent?: number | null;
+    }, { user }: {
+        user: {
+            id: string | number;
+        };
+    }) => Promise<any>;
+    setPathIdAndPath: (folder: Pick<import("../types").Folder, "parent">) => Promise<Pick<import("../types").Folder, "parent"> & {
+        pathId: number;
+        path: string;
+    }>;
+    getStructure: () => Promise<number[] & (Partial<import("../types").Folder> & {
+        children: (Partial<import("../types").Folder> & /*elided*/ any)[];
+    })[]>;
+};
+//# sourceMappingURL=ambient-instance.d.ts.map

package/dist/server/src/mcp/ambient-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-instance.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/ambient-instance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,IAAI,CAAC,MAAM,SASxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,IAAI,CAAC,MAAM;;;;;;;;;;;;;;cACwX,CAAC;;;;;;;;;;;;;CADxV,CAAC"}

package/dist/server/src/mcp/handlers/constants.d.ts

@@ -0,0 +1,48 @@
+export declare const MCP_NOT_FOUND_ASSET = "Media asset not found.";
+export declare const MCP_UPDATE_ASSET_NO_FIELDS = "Provide at least one field to update: name, alternativeText or caption. To move an asset between folders use media_move_assets; url, mime, size and the file contents are owned by the upload provider and cannot be edited over MCP.";
+export declare const MCP_NOT_FOUND_FOLDER = "Media folder not found.";
+export declare const MCP_FOLDER_NAME_TAKEN = "A folder with this name already exists in the same parent folder. Folder names must be unique among siblings.";
+export declare const MCP_PARENT_FOLDER_NOT_FOUND = "The parent folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.";
+export declare const MCP_FOLDER_MOVE_INTO_SELF = "A folder cannot be moved into itself or into one of its own descendants.";
+/**
+ * Returned when `media_delete_folder` is handed any id that does not resolve to a folder.
+ *
+ * Names the offending ids, because the call rejects as a whole: the agent has to know which
+ * entries to drop or correct, and cannot infer that from a generic failure. Folder ids and
+ * asset ids are indistinguishable integers, so an asset id is the likeliest cause and is named
+ * first — but a deleted or never-existent folder id looks the same from here, so the message
+ * covers both rather than asserting one.
+ */
+export declare const MCP_DELETE_FOLDER_UNRESOLVED_IDS: (ids: number[]) => string;
+export declare const MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND = "The destination folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.";
+/** Per-id `failed` reasons for `media_move_assets`. Both are per asset, so the wording names the id's fate, not the call's. */
+export declare const MCP_MOVE_ASSETS_ID_NOT_FOUND = "No media asset has this id, so nothing was moved for it. If this is a folder id, use media_move_folder \u2014 and note that a folder id only fails like this when no asset happens to share the number; when one does, media_move_assets moves that asset instead. Otherwise the asset may already be deleted \u2014 use media_list_assets to discover valid asset ids.";
+export declare const MCP_MOVE_ASSETS_ID_FORBIDDEN = "This token is not allowed to edit this asset. A permission condition on plugin::upload.assets.update excludes it.";
+/**
+ * Returned when the move of one asset failed for a reason that is not a missing asset or a
+ * permission denial — a DB error, say, or an upload-provider fault.
+ *
+ * Reported per id rather than thrown: a tool error carries no `structuredContent`, so throwing
+ * would discard the report naming the assets that had already moved in the same call.
+ * `cause` is the underlying message, kept verbatim so the real fault stays legible.
+ */
+export declare const MCP_MOVE_ASSETS_ID_FAILED: (cause: string) => string;
+/**
+ * Per-id `failed` reasons for `media_delete_assets`, and the dry-run's `failed` reason.
+ *
+ * Reported per id rather than thrown, because a delete is irreversible: an error carries no
+ * `structuredContent`, so throwing on the third id would discard the report saying the first
+ * two are already gone — and no re-read can recover what was deleted.
+ */
+export declare const MCP_DELETE_ASSETS_ID_NOT_FOUND = "No media asset has this id, so nothing was deleted for it. If this is a folder id, use media_delete_folder \u2014 and note that a folder id only fails like this when no asset happens to share the number; when one does, media_delete_assets deletes that asset instead. Otherwise the asset may already be deleted; use media_list_assets to discover valid asset ids.";
+export declare const MCP_DELETE_ASSETS_ID_FORBIDDEN = "This token is not allowed to delete this asset. A permission condition on plugin::upload.assets.update excludes it.";
+/**
+ * Returned when the deletion of one asset failed for a reason that is not a missing asset or a
+ * permission denial — a DB error, say, or an upload-provider fault.
+ *
+ * `cause` is the underlying message, kept verbatim so the real fault stays legible. The asset
+ * may be half-removed (the provider file gone, the row still present, or the reverse), so the
+ * wording tells the agent to re-read rather than assume either outcome.
+ */
+export declare const MCP_DELETE_ASSETS_ID_FAILED: (cause: string) => string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/server/src/mcp/handlers/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAE5D,eAAO,MAAM,0BAA0B,0OACkM,CAAC;AAE1O,eAAO,MAAM,oBAAoB,4BAA4B,CAAC;AAE9D,eAAO,MAAM,qBAAqB,kHAC+E,CAAC;AAElH,eAAO,MAAM,2BAA2B,oIAC2F,CAAC;AAEpI,eAAO,MAAM,yBAAyB,6EACsC,CAAC;AAE7E;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,GAAI,KAAK,MAAM,EAAE,WACgV,CAAC;AAE/Y,eAAO,MAAM,qCAAqC,yIACsF,CAAC;AAEzI,+HAA+H;AAC/H,eAAO,MAAM,4BAA4B,4WACwT,CAAC;AAElW,eAAO,MAAM,4BAA4B,sHAC4E,CAAC;AAEtH;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,WACsJ,CAAC;AAE9M;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,8WAC6T,CAAC;AAEzW,eAAO,MAAM,8BAA8B,wHAC4E,CAAC;AAExH;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GAAI,OAAO,MAAM,WAC6H,CAAC"}

package/dist/server/src/mcp/handlers/folder-handlers.d.ts

@@ -0,0 +1,49 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * `media_create_folder` — a new folder, optionally nested.
+ *
+ * Gated on `plugin::upload.assets.create` and mirrors `POST /upload/folders`: the same
+ * permission, the same uniqueness and parent-existence validation, the same `folder.create()`
+ * call, and the same `createdBy` attribution from the session user.
+ *
+ * `create` rather than the `update` the other folder tools use: creating a folder is the one
+ * folder operation whose admin route gates on `assets.create`.
+ */
+export declare const createMediaCreateFolderHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_rename_folder` — changes a folder's name and nothing else.
+ *
+ * Deliberately does not forward `parent` to `folder.update()`: the service branches on
+ * `isUndefined(parent)`, and the name-only branch skips the transaction that rewrites descendant
+ * paths. Passing the folder's existing parent would take the move branch and rewrite the whole
+ * subtree to compute the identical paths.
+ */
+export declare const createMediaRenameFolderHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_move_folder` — re-parents a folder, carrying its whole subtree with it.
+ *
+ * `folder.update()` recalculates the materialized `path` of every descendant folder and the
+ * `folderPath` of every contained file inside a transaction, so the move is atomic and no
+ * separate bookkeeping is needed here.
+ */
+export declare const createMediaMoveFolderHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_delete_folder` — previews or performs a cascading folder deletion.
+ *
+ * Two branches behind one tool, because the preview and the deletion must agree on what the
+ * cascade covers; splitting them across tools would let the two drift apart, and an agent could
+ * reach the destructive one without ever seeing a count.
+ *
+ * `dryRun` defaults to true (see the input schema): omitting the flag previews, and deleting
+ * takes an explicit `dryRun: false`.
+ */
+export declare const createMediaDeleteFolderHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+//# sourceMappingURL=folder-handlers.d.ts.map

package/dist/server/src/mcp/handlers/folder-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-handlers.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/folder-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AA4KnD;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAY7C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAsB7C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAyB7C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAuD7C,CAAC"}

package/dist/server/src/mcp/handlers/index.d.ts

@@ -0,0 +1,5 @@
+export { createMediaListAssetsHandler, createMediaGetAssetHandler, createMediaListFoldersHandler, } from './read-handlers';
+export { createMediaUpdateAssetHandler, createMediaMoveAssetsHandler, createMediaDeleteAssetsHandler, } from './write-handlers';
+export { createMediaCreateFolderHandler, createMediaRenameFolderHandler, createMediaMoveFolderHandler, createMediaDeleteFolderHandler, } from './folder-handlers';
+export { MCP_NOT_FOUND_ASSET, MCP_UPDATE_ASSET_NO_FIELDS, MCP_NOT_FOUND_FOLDER, MCP_FOLDER_NAME_TAKEN, MCP_PARENT_FOLDER_NOT_FOUND, MCP_FOLDER_MOVE_INTO_SELF, MCP_DELETE_FOLDER_UNRESOLVED_IDS, MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND, MCP_MOVE_ASSETS_ID_NOT_FOUND, MCP_MOVE_ASSETS_ID_FORBIDDEN, MCP_MOVE_ASSETS_ID_FAILED, MCP_DELETE_ASSETS_ID_NOT_FOUND, MCP_DELETE_ASSETS_ID_FORBIDDEN, MCP_DELETE_ASSETS_ID_FAILED, } from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/mcp/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,6BAA6B,EAC7B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,8BAA8B,EAC9B,8BAA8B,EAC9B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,yBAAyB,EACzB,gCAAgC,EAChC,qCAAqC,EACrC,4BAA4B,EAC5B,4BAA4B,EAC5B,yBAAyB,EACzB,8BAA8B,EAC9B,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,aAAa,CAAC"}

package/dist/server/src/mcp/handlers/read-handlers.d.ts

@@ -0,0 +1,35 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * `media_list_assets` — paginated, filtered listing of media files.
+ *
+ * Permission conditions are applied through the permissions manager
+ * (`addPermissionsQueryTo`) so a token restricted by a condition — e.g. own-assets-only —
+ * sees the same subset it would through the admin API.
+ */
+export declare const createMediaListAssetsHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_get_asset` — a single asset by numeric id.
+ *
+ * Row-level permission *conditions* are enforced by `findEntityAndCheckPermissions`, the same
+ * helper the admin `findOne` controller uses: it populates `createdBy` and the creator's roles
+ * before building the CASL subject, which is what the admin conditions read. Checking a subject
+ * without those fields would deny a conditioned grant its own assets, and would disagree with
+ * `media_list_assets`, where the condition is pushed into the query instead.
+ */
+export declare const createMediaGetAssetHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_list_folders` — the nested folder structure, reusing `folder.getStructure()`.
+ *
+ * `getStructure()` returns the whole tree in one query and has no permission-condition
+ * filtering, so this is gated on the model-level read permission only — matching
+ * `GET /upload/folder-structure` in the admin API.
+ *
+ * The factory asserts the handler's instance is the ambient `global.strapi` the folder service
+ * actually queries — see `assertAmbientInstance` for why.
+ */
+export declare const createMediaListFoldersHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => () => Promise<Modules.MCP.McpToolHandlerReturn>;
+//# sourceMappingURL=read-handlers.d.ts.map

package/dist/server/src/mcp/handlers/read-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-handlers.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/read-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AA4DnD;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAmB7C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GACrC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CA0B7C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,WAIrB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAO1D,CAAC"}

package/dist/server/src/mcp/handlers/write-handlers.d.ts

@@ -0,0 +1,66 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * `media_update_asset` — edits the writable metadata of one asset.
+ *
+ * Gated on `plugin::upload.assets.update` and mirrors `PUT /upload/files/:id`: the same
+ * `findEntityAndCheckPermissions` row-level check, the same `updateFileInfo` service call, and
+ * the same `updatedBy` attribution from the session user.
+ *
+ * The response carries the updated asset through the read sanitizer, so a client can confirm
+ * the write without a second `media_get_asset` round-trip — and so provider fields stay
+ * invisible on the write path too.
+ */
+export declare const createMediaUpdateAssetHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_move_assets` — moves assets between folders in bulk.
+ *
+ * Bulk with a per-id report, rather than all-or-nothing: an agent reorganising a library moves
+ * many assets at once, and one bad id among good ones must not discard the valid moves. Each
+ * asset is moved on its own, so a failure is confined to its own id and the response says exactly
+ * which ids to retry.
+ *
+ * That is why this does not reuse the admin `/actions/bulk-move` controller path, whose single
+ * transaction is all-or-nothing by construction (and which also handles folders, out of scope
+ * here). It goes through `updateFileInfo` instead — the same service `media_update_asset` and
+ * `PUT /upload/files/:id` use — which sets the `folder` relation, recomputes the private
+ * `folderPath`, attributes `updatedBy`, and emits `media.update` per asset. Replicating the
+ * controller's raw join-table writes would skip all four.
+ *
+ * The moves are sequential on purpose. Each one writes the join table and `folderPath` for its
+ * asset, and a bounded reorganisation (100 ids max, per the input schema) is not worth the
+ * connection-pool contention of firing them in parallel.
+ */
+export declare const createMediaMoveAssetsHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_delete_assets` — previews or performs the permanent deletion of assets, in bulk.
+ *
+ * Two branches behind one tool, for the same reason as `media_delete_folder`: the preview and the
+ * deletion must agree on what would be destroyed, and splitting them across tools would both let
+ * the two drift apart and let an agent reach the destructive one without ever seeing a preview.
+ * `dryRun` defaults to true (see the input schema), so omitting the flag previews and deleting
+ * takes an explicit `dryRun: false`.
+ *
+ * Per-id, not all-or-nothing — the opposite of `media_delete_folder`, on purpose. A folder delete
+ * cascades, so a mixed id list there is refused outright rather than half-applied over an unknown
+ * amount of content. Here each id is exactly one asset, the blast radius of a bad one is nil, and
+ * the requirement is explicit: a bad id among good ones must not discard the valid deletions.
+ * The dry run reports the same per-id split, so an agent sees which ids will not resolve *before*
+ * anything is destroyed rather than after.
+ *
+ * This does not reuse `file.deleteByIds` (the admin `/actions/bulk-delete` path). That helper
+ * fires `upload.remove` under a single `Promise.all`, so the first rejection discards the report
+ * of everything already deleted — unrecoverable for an operation with no undo. The removals are
+ * driven one at a time here instead, through the same `upload.remove` service, which deletes the
+ * provider file and every generated format, emits `media.delete`, and then deletes the row.
+ *
+ * The deletions are sequential on purpose: each one performs provider I/O, and a bounded batch
+ * (100 ids max, per the input schema) is not worth firing at a provider in parallel.
+ */
+export declare const createMediaDeleteAssetsHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+//# sourceMappingURL=write-handlers.d.ts.map

package/dist/server/src/mcp/handlers/write-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-handlers.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/write-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAiEnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CA4C7C,CAAC;AA8BF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAgF7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAmF7C,CAAC"}

package/dist/server/src/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { registerUploadMcpTools, buildUploadMcpToolDefinitions } from './register-upload-mcp-tools';
+export type { UploadMcpTool } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AACpG,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/server/src/mcp/permissions.d.ts

@@ -0,0 +1,22 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * Builds an admin permissions manager for a media model bound to the MCP session's ability.
+ *
+ * MCP tool handlers have no Koa context, so they cannot rely on route policies: each handler must
+ * re-check permissions itself, exactly as the admin controllers do via `ctx.state.userAbility`.
+ * The declarative `auth.policies` on a tool definition already gates registration and invocation;
+ * this second check is what keeps a handler safe if it is ever called from another entry point.
+ *
+ * It is also the only check bound to a model. `plugin::upload.read` is registered in the
+ * `plugins` section with no subject (see the upload plugin bootstrap), so a tool's policies
+ * carry an action only — a subject-less grant registers as CASL `subject: 'all'`. Passing a
+ * model UID as the policy subject is rejected by the admin-token validation, so the file /
+ * folder distinction is enforced here, where the permissions manager is bound to the UID.
+ */
+export declare const createMediaPermissionsManager: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext, action: string, model: string) => any;
+/**
+ * Throws `ForbiddenError` unless the session's ability permits `action` on `model`.
+ * Mirrors the `if (!pm.isAllowed) return ctx.forbidden()` guard in the admin controllers.
+ */
+export declare const assertMediaPermission: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext, action: string, model: string) => any;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/server/src/mcp/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,EACtC,QAAQ,MAAM,EACd,OAAO,MAAM,QAMX,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,EACtC,QAAQ,MAAM,EACd,OAAO,MAAM,QASd,CAAC"}

package/dist/server/src/mcp/register-upload-mcp-tools.d.ts

@@ -0,0 +1,29 @@
+import type { Core } from '@strapi/types';
+import type { UploadMcpTool } from './types';
+/**
+ * The Media Library MCP tools.
+ *
+ * Folder writes inherit the same `plugin::upload.assets.update` action rather than introducing a
+ * folder-specific one, matching what the admin UI enforces today. MCP-specific folder RBAC is
+ * out of scope.
+ *
+ * Renaming and moving are separate tools for both objects — rename/update changes attributes,
+ * move changes location — so an agent selects by intent instead of assembling a combined patch.
+ *
+ * The asset and folder tools stay separate for both move and delete, even though
+ * `/actions/bulk-move` accepts both id lists at once and `/actions/bulk-delete` accepts `fileIds`
+ * and `folderIds` together. Asset ids and folder ids are indistinguishable integers from separate
+ * namespaces, and both `media_list_assets` and `media_list_folders` return a plain `id`, so a
+ * combined tool would let an agent pass folder ids where assets were meant with nothing to
+ * object. On the delete side that mistake is unrecoverable, and two tools also let each
+ * description carry the warning matched to its own blast radius.
+ */
+export declare const buildUploadMcpToolDefinitions: () => UploadMcpTool[];
+/**
+ * Registers the Media Library MCP tools via `strapi.ai.mcp.registerTool()`.
+ * Must be called from the plugin register phase, before the MCP HTTP server starts.
+ */
+export declare const registerUploadMcpTools: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+//# sourceMappingURL=register-upload-mcp-tools.d.ts.map

package/dist/server/src/mcp/register-upload-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-upload-mcp-tools.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/register-upload-mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAmC7C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,6BAA6B,QAAO,aAAa,EAiH7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,YAAY;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAA;CAAE,KAAG,IAO5E,CAAC"}

package/dist/server/src/mcp/sanitizers/sanitize-media.d.ts

@@ -0,0 +1,63 @@
+import type { MediaFolderNode } from '../schemas';
+type RawFolder = {
+    id?: unknown;
+    name?: unknown;
+    children?: unknown;
+};
+type RawAsset = Record<string, unknown> & {
+    folder?: RawFolder | null;
+};
+/**
+ * Projects a raw file row onto the MCP asset shape.
+ *
+ * This is an allowlist: every exposed key is named explicitly, so `provider`,
+ * `provider_metadata` (which can carry provider credentials), `hash`, `formats`, `related`,
+ * and the private `folderPath` never reach an MCP client — including after new fields are
+ * added to the file content-type.
+ */
+export declare const sanitizeMediaAsset: (asset: RawAsset) => {
+    id: number;
+    name: string;
+    alternativeText: string | null;
+    caption: string | null;
+    url: string;
+    mime: string;
+    size: number;
+    width: number | null;
+    height: number | null;
+    ext: string | null;
+    folder: {
+        id: number;
+        name: string;
+    } | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+/**
+ * Projects the recursive output of `folder.getStructure()` onto `{ id, name, children }`,
+ * dropping `path` and `pathId` (internal materialized-path bookkeeping).
+ */
+export declare const sanitizeMediaFolderTree: (nodes: unknown) => MediaFolderNode[];
+/**
+ * Projects a raw folder row onto the MCP folder shape.
+ *
+ * An allowlist for the same reason as `sanitizeMediaAsset`: `path` and `pathId` are the internal
+ * materialized-path bookkeeping the folder service uses to cascade moves and deletes. Exposing
+ * them would invite an agent to treat them as addressable, and any field added to the folder
+ * content-type later stays invisible until it is named here on purpose.
+ */
+export declare const sanitizeMediaFolder: (folder: (RawFolder & Record<string, unknown>) | null | undefined) => {
+    createdAt: string | null;
+    updatedAt: string | null;
+    parent?: {
+        id: number;
+        name?: undefined;
+    } | {
+        id: number;
+        name: string;
+    } | null | undefined;
+    id: number;
+    name: string;
+} | null;
+export {};
+//# sourceMappingURL=sanitize-media.d.ts.map

package/dist/server/src/mcp/sanitizers/sanitize-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-media.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/sanitizers/sanitize-media.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,KAAK,SAAS,GAAG;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACxC,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC3B,CAAC;AAeF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,QAAQ;;;;;;;;;;;;;;;;;CAqBjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,eAAe,EAQvE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;;;;;;;;;;;;QA+BjE,CAAC"}

package/dist/server/src/mcp/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export { mediaIdSchema, folderIdSchema, folderNameSchema, pageSchema, pageSizeSchema, sortSchema, mediaListAssetsInputSchema, mediaGetAssetInputSchema, mediaListFoldersInputSchema, mediaUpdateAssetInputSchema, mediaCreateFolderInputSchema, mediaRenameFolderInputSchema, mediaMoveFolderInputSchema, mediaDeleteFolderInputSchema, mediaMoveAssetsInputSchema, mediaDeleteAssetsInputSchema, } from './input-schemas';
+export { mediaAssetOutputSchema, mediaGetAssetOutputSchema, mediaListAssetsOutputSchema, mediaFolderNodeSchema, mediaListFoldersOutputSchema, mediaUpdateAssetOutputSchema, mediaFolderOutputSchema, mediaCreateFolderOutputSchema, mediaRenameFolderOutputSchema, mediaMoveFolderOutputSchema, mediaDeleteFolderOutputSchema, mediaMoveAssetsFailureSchema, mediaMoveAssetsOutputSchema, mediaDeleteAssetsFailureSchema, mediaDeleteAssetsOutputSchema, type MediaFolderNode, } from './output-schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/mcp/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,UAAU,EACV,0BAA0B,EAC1B,wBAAwB,EACxB,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,EACrB,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,6BAA6B,EAC7B,4BAA4B,EAC5B,2BAA2B,EAC3B,8BAA8B,EAC9B,6BAA6B,EAC7B,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC"}