@strapi/upload 5.53.0 → 5.54.0

package/dist/server/mcp/ambient-instance.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var index = require('../utils/index.js');
+
+/**
+ * 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.
+ */ const assertAmbientInstance = (strapi)=>{
+    if (strapi !== global.strapi) {
+        throw new Error('The upload `folder` and `file` services are bound to the ambient `global.strapi`, but an ' + 'MCP handler was constructed with a different Strapi instance. Media queries would run ' + 'against the wrong app. Convert those services to factories before serving MCP from a ' + 'non-global instance.');
+    }
+};
+/**
+ * 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.
+ */ const getFolderService = (strapi)=>index.getService('folder', strapi);
+
+exports.assertAmbientInstance = assertAmbientInstance;
+exports.getFolderService = getFolderService;
+//# sourceMappingURL=ambient-instance.js.map

package/dist/server/mcp/ambient-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-instance.js","sources":["../../../server/src/mcp/ambient-instance.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\n\nimport { getService } from '../utils';\n\n/**\n * Asserts that an MCP handler's Strapi instance is the ambient `global.strapi`.\n *\n * Two of the upload plugin's services — `folder` and `file` — are registered as plain object\n * literals rather than factories (see `services/index.ts`), so their methods close over the\n * module-scope ambient `strapi` and query `global.strapi.db` regardless of which instance is\n * passed to `getService`. Passing an instance therefore selects the right plugin registry but\n * does *not* bind the queries to it.\n *\n * The folder tools reach `folder` directly. The asset write tools reach `file` transitively:\n * `upload.updateFileInfo` resolves it with a bare `getService('file')` (`services/upload.ts`),\n * and `file.getFolderPath` then queries the ambient `strapi.db`. So a handler that looks\n * instance-bound can still mix ambient reads with instance-bound writes.\n *\n * Threading an instance through both services is a broader refactor than the MCP surface should\n * carry: `create`, `update` and `deleteByIds` reach for `strapi.db`, `strapi.eventHub` and\n * `strapi.getModel`, `update` runs a multi-statement transaction, and every admin controller and\n * validator already depends on the ambient form.\n *\n * So the dependency is made explicit and asserted instead. Handlers call this in their factory\n * body — at handler construction, not per call — so a mismatch fails while the tool is being\n * registered rather than surfacing to an agent as tool output mid-conversation.\n *\n * A single-app server is unaffected: `createStrapi` assigns its instance to `global.strapi`, so\n * the two agree. If they ever diverge — a second Strapi instance in one process — this throws\n * rather than silently reading or writing the wrong app's media library.\n */\nexport const assertAmbientInstance = (strapi: Core.Strapi) => {\n  if (strapi !== global.strapi) {\n    throw new Error(\n      'The upload `folder` and `file` services are bound to the ambient `global.strapi`, but an ' +\n        'MCP handler was constructed with a different Strapi instance. Media queries would run ' +\n        'against the wrong app. Convert those services to factories before serving MCP from a ' +\n        'non-global instance.'\n    );\n  }\n};\n\n/**\n * Resolves the `folder` service for an MCP handler.\n *\n * A bare `getService('folder', strapi)` reads as instance-bound but is not — see\n * `assertAmbientInstance` for why. Handlers assert the instance once at construction; this keeps\n * the resolution behind a named helper so the call sites do not reintroduce the misleading form.\n */\nexport const getFolderService = (strapi: Core.Strapi) => getService('folder', strapi);\n"],"names":["assertAmbientInstance","strapi","global","Error","getFolderService","getService"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BO,MAAMA,qBAAAA,GAAwB,CAACC,MAAAA,GAAAA;IACpC,IAAIA,MAAAA,KAAWC,MAAAA,CAAOD,MAAM,EAAE;AAC5B,QAAA,MAAM,IAAIE,KAAAA,CACR,2FAAA,GACE,wFAAA,GACA,uFAAA,GACA,sBAAA,CAAA;AAEN,IAAA;AACF;AAEA;;;;;;AAMC,IACM,MAAMC,gBAAAA,GAAmB,CAACH,MAAAA,GAAwBI,gBAAAA,CAAW,UAAUJ,MAAAA;;;;;"}

package/dist/server/mcp/ambient-instance.mjs

@@ -0,0 +1,43 @@
+import { getService } from '../utils/index.mjs';
+
+/**
+ * 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.
+ */ const assertAmbientInstance = (strapi)=>{
+    if (strapi !== global.strapi) {
+        throw new Error('The upload `folder` and `file` services are bound to the ambient `global.strapi`, but an ' + 'MCP handler was constructed with a different Strapi instance. Media queries would run ' + 'against the wrong app. Convert those services to factories before serving MCP from a ' + 'non-global instance.');
+    }
+};
+/**
+ * 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.
+ */ const getFolderService = (strapi)=>getService('folder', strapi);
+
+export { assertAmbientInstance, getFolderService };
+//# sourceMappingURL=ambient-instance.mjs.map

package/dist/server/mcp/ambient-instance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-instance.mjs","sources":["../../../server/src/mcp/ambient-instance.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\n\nimport { getService } from '../utils';\n\n/**\n * Asserts that an MCP handler's Strapi instance is the ambient `global.strapi`.\n *\n * Two of the upload plugin's services — `folder` and `file` — are registered as plain object\n * literals rather than factories (see `services/index.ts`), so their methods close over the\n * module-scope ambient `strapi` and query `global.strapi.db` regardless of which instance is\n * passed to `getService`. Passing an instance therefore selects the right plugin registry but\n * does *not* bind the queries to it.\n *\n * The folder tools reach `folder` directly. The asset write tools reach `file` transitively:\n * `upload.updateFileInfo` resolves it with a bare `getService('file')` (`services/upload.ts`),\n * and `file.getFolderPath` then queries the ambient `strapi.db`. So a handler that looks\n * instance-bound can still mix ambient reads with instance-bound writes.\n *\n * Threading an instance through both services is a broader refactor than the MCP surface should\n * carry: `create`, `update` and `deleteByIds` reach for `strapi.db`, `strapi.eventHub` and\n * `strapi.getModel`, `update` runs a multi-statement transaction, and every admin controller and\n * validator already depends on the ambient form.\n *\n * So the dependency is made explicit and asserted instead. Handlers call this in their factory\n * body — at handler construction, not per call — so a mismatch fails while the tool is being\n * registered rather than surfacing to an agent as tool output mid-conversation.\n *\n * A single-app server is unaffected: `createStrapi` assigns its instance to `global.strapi`, so\n * the two agree. If they ever diverge — a second Strapi instance in one process — this throws\n * rather than silently reading or writing the wrong app's media library.\n */\nexport const assertAmbientInstance = (strapi: Core.Strapi) => {\n  if (strapi !== global.strapi) {\n    throw new Error(\n      'The upload `folder` and `file` services are bound to the ambient `global.strapi`, but an ' +\n        'MCP handler was constructed with a different Strapi instance. Media queries would run ' +\n        'against the wrong app. Convert those services to factories before serving MCP from a ' +\n        'non-global instance.'\n    );\n  }\n};\n\n/**\n * Resolves the `folder` service for an MCP handler.\n *\n * A bare `getService('folder', strapi)` reads as instance-bound but is not — see\n * `assertAmbientInstance` for why. Handlers assert the instance once at construction; this keeps\n * the resolution behind a named helper so the call sites do not reintroduce the misleading form.\n */\nexport const getFolderService = (strapi: Core.Strapi) => getService('folder', strapi);\n"],"names":["assertAmbientInstance","strapi","global","Error","getFolderService","getService"],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BO,MAAMA,qBAAAA,GAAwB,CAACC,MAAAA,GAAAA;IACpC,IAAIA,MAAAA,KAAWC,MAAAA,CAAOD,MAAM,EAAE;AAC5B,QAAA,MAAM,IAAIE,KAAAA,CACR,2FAAA,GACE,wFAAA,GACA,uFAAA,GACA,sBAAA,CAAA;AAEN,IAAA;AACF;AAEA;;;;;;AAMC,IACM,MAAMC,gBAAAA,GAAmB,CAACH,MAAAA,GAAwBI,UAAAA,CAAW,UAAUJ,MAAAA;;;;"}

package/dist/server/mcp/handlers/constants.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const MCP_NOT_FOUND_ASSET = 'Media asset not found.';
+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.';
+const MCP_NOT_FOUND_FOLDER = 'Media folder not found.';
+const MCP_FOLDER_NAME_TAKEN = 'A folder with this name already exists in the same parent folder. Folder names must be unique among siblings.';
+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.';
+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.
+ */ const MCP_DELETE_FOLDER_UNRESOLVED_IDS = (ids)=>`These ids do not match any media folder: ${ids.join(', ')}. Nothing was deleted — media_delete_folder rejects the whole request rather than deleting the folders that did match, because folder ids and asset ids are indistinguishable integers. If these are asset ids, use media_delete_assets instead; otherwise the folders may already be gone. Use media_list_folders to discover valid folder ids.`;
+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. */ 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 — 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 — use media_list_assets to discover valid asset ids.';
+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.
+ */ const MCP_MOVE_ASSETS_ID_FAILED = (cause)=>`Moving this asset failed: ${cause}. This is not a problem with the id itself — the asset exists and this token may edit it — so retrying may succeed. Any assets listed under \`moved\` were still moved.`;
+/**
+ * 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.
+ */ 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 — 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.';
+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.
+ */ const MCP_DELETE_ASSETS_ID_FAILED = (cause)=>`Deleting this asset failed: ${cause}. The asset may be partially removed — re-read it with media_get_asset before retrying. Any assets listed under \`deleted\` are gone for good.`;
+
+exports.MCP_DELETE_ASSETS_ID_FAILED = MCP_DELETE_ASSETS_ID_FAILED;
+exports.MCP_DELETE_ASSETS_ID_FORBIDDEN = MCP_DELETE_ASSETS_ID_FORBIDDEN;
+exports.MCP_DELETE_ASSETS_ID_NOT_FOUND = MCP_DELETE_ASSETS_ID_NOT_FOUND;
+exports.MCP_DELETE_FOLDER_UNRESOLVED_IDS = MCP_DELETE_FOLDER_UNRESOLVED_IDS;
+exports.MCP_FOLDER_MOVE_INTO_SELF = MCP_FOLDER_MOVE_INTO_SELF;
+exports.MCP_FOLDER_NAME_TAKEN = MCP_FOLDER_NAME_TAKEN;
+exports.MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND = MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND;
+exports.MCP_MOVE_ASSETS_ID_FAILED = MCP_MOVE_ASSETS_ID_FAILED;
+exports.MCP_MOVE_ASSETS_ID_FORBIDDEN = MCP_MOVE_ASSETS_ID_FORBIDDEN;
+exports.MCP_MOVE_ASSETS_ID_NOT_FOUND = MCP_MOVE_ASSETS_ID_NOT_FOUND;
+exports.MCP_NOT_FOUND_ASSET = MCP_NOT_FOUND_ASSET;
+exports.MCP_NOT_FOUND_FOLDER = MCP_NOT_FOUND_FOLDER;
+exports.MCP_PARENT_FOLDER_NOT_FOUND = MCP_PARENT_FOLDER_NOT_FOUND;
+exports.MCP_UPDATE_ASSET_NO_FIELDS = MCP_UPDATE_ASSET_NO_FIELDS;
+//# sourceMappingURL=constants.js.map

package/dist/server/mcp/handlers/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../server/src/mcp/handlers/constants.ts"],"sourcesContent":["export const MCP_NOT_FOUND_ASSET = 'Media asset not found.';\n\nexport const MCP_UPDATE_ASSET_NO_FIELDS =\n  '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.';\n\nexport const MCP_NOT_FOUND_FOLDER = 'Media folder not found.';\n\nexport const MCP_FOLDER_NAME_TAKEN =\n  'A folder with this name already exists in the same parent folder. Folder names must be unique among siblings.';\n\nexport const MCP_PARENT_FOLDER_NOT_FOUND =\n  'The parent folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.';\n\nexport const MCP_FOLDER_MOVE_INTO_SELF =\n  'A folder cannot be moved into itself or into one of its own descendants.';\n\n/**\n * Returned when `media_delete_folder` is handed any id that does not resolve to a folder.\n *\n * Names the offending ids, because the call rejects as a whole: the agent has to know which\n * entries to drop or correct, and cannot infer that from a generic failure. Folder ids and\n * asset ids are indistinguishable integers, so an asset id is the likeliest cause and is named\n * first — but a deleted or never-existent folder id looks the same from here, so the message\n * covers both rather than asserting one.\n */\nexport const MCP_DELETE_FOLDER_UNRESOLVED_IDS = (ids: number[]) =>\n  `These ids do not match any media folder: ${ids.join(', ')}. Nothing was deleted — media_delete_folder rejects the whole request rather than deleting the folders that did match, because folder ids and asset ids are indistinguishable integers. If these are asset ids, use media_delete_assets instead; otherwise the folders may already be gone. Use media_list_folders to discover valid folder ids.`;\n\nexport const MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND =\n  'The destination folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.';\n\n/** Per-id `failed` reasons for `media_move_assets`. Both are per asset, so the wording names the id's fate, not the call's. */\nexport const MCP_MOVE_ASSETS_ID_NOT_FOUND =\n  'No media asset has this id, so nothing was moved for it. If this is a folder id, use media_move_folder — 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 — use media_list_assets to discover valid asset ids.';\n\nexport const MCP_MOVE_ASSETS_ID_FORBIDDEN =\n  'This token is not allowed to edit this asset. A permission condition on plugin::upload.assets.update excludes it.';\n\n/**\n * Returned when the move of one asset failed for a reason that is not a missing asset or a\n * permission denial — a DB error, say, or an upload-provider fault.\n *\n * Reported per id rather than thrown: a tool error carries no `structuredContent`, so throwing\n * would discard the report naming the assets that had already moved in the same call.\n * `cause` is the underlying message, kept verbatim so the real fault stays legible.\n */\nexport const MCP_MOVE_ASSETS_ID_FAILED = (cause: string) =>\n  `Moving this asset failed: ${cause}. This is not a problem with the id itself — the asset exists and this token may edit it — so retrying may succeed. Any assets listed under \\`moved\\` were still moved.`;\n\n/**\n * Per-id `failed` reasons for `media_delete_assets`, and the dry-run's `failed` reason.\n *\n * Reported per id rather than thrown, because a delete is irreversible: an error carries no\n * `structuredContent`, so throwing on the third id would discard the report saying the first\n * two are already gone — and no re-read can recover what was deleted.\n */\nexport const MCP_DELETE_ASSETS_ID_NOT_FOUND =\n  'No media asset has this id, so nothing was deleted for it. If this is a folder id, use media_delete_folder — 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.';\n\nexport const MCP_DELETE_ASSETS_ID_FORBIDDEN =\n  'This token is not allowed to delete this asset. A permission condition on plugin::upload.assets.update excludes it.';\n\n/**\n * Returned when the deletion of one asset failed for a reason that is not a missing asset or a\n * permission denial — a DB error, say, or an upload-provider fault.\n *\n * `cause` is the underlying message, kept verbatim so the real fault stays legible. The asset\n * may be half-removed (the provider file gone, the row still present, or the reverse), so the\n * wording tells the agent to re-read rather than assume either outcome.\n */\nexport const MCP_DELETE_ASSETS_ID_FAILED = (cause: string) =>\n  `Deleting this asset failed: ${cause}. The asset may be partially removed — re-read it with media_get_asset before retrying. Any assets listed under \\`deleted\\` are gone for good.`;\n"],"names":["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","ids","join","MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND","MCP_MOVE_ASSETS_ID_NOT_FOUND","MCP_MOVE_ASSETS_ID_FORBIDDEN","MCP_MOVE_ASSETS_ID_FAILED","cause","MCP_DELETE_ASSETS_ID_NOT_FOUND","MCP_DELETE_ASSETS_ID_FORBIDDEN","MCP_DELETE_ASSETS_ID_FAILED"],"mappings":";;AAAO,MAAMA,sBAAsB;AAE5B,MAAMC,6BACX;AAEK,MAAMC,uBAAuB;AAE7B,MAAMC,wBACX;AAEK,MAAMC,8BACX;AAEK,MAAMC,4BACX;AAEF;;;;;;;;AAQC,IACM,MAAMC,gCAAAA,GAAmC,CAACC,MAC/C,CAAC,yCAAyC,EAAEA,GAAAA,CAAIC,IAAI,CAAC,IAAA,CAAA,CAAM,gVAAgV;AAEtY,MAAMC,wCACX;AAEF,gIACO,MAAMC,4BAAAA,GACX;AAEK,MAAMC,+BACX;AAEF;;;;;;;IAQO,MAAMC,yBAAAA,GAA4B,CAACC,KAAAA,GACxC,CAAC,0BAA0B,EAAEA,KAAAA,CAAM,uKAAuK;AAE5M;;;;;;IAOO,MAAMC,8BAAAA,GACX;AAEK,MAAMC,iCACX;AAEF;;;;;;;IAQO,MAAMC,2BAAAA,GAA8B,CAACH,KAAAA,GAC1C,CAAC,4BAA4B,EAAEA,KAAAA,CAAM,8IAA8I;;;;;;;;;;;;;;;;;"}

package/dist/server/mcp/handlers/constants.mjs

@@ -0,0 +1,45 @@
+const MCP_NOT_FOUND_ASSET = 'Media asset not found.';
+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.';
+const MCP_NOT_FOUND_FOLDER = 'Media folder not found.';
+const MCP_FOLDER_NAME_TAKEN = 'A folder with this name already exists in the same parent folder. Folder names must be unique among siblings.';
+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.';
+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.
+ */ const MCP_DELETE_FOLDER_UNRESOLVED_IDS = (ids)=>`These ids do not match any media folder: ${ids.join(', ')}. Nothing was deleted — media_delete_folder rejects the whole request rather than deleting the folders that did match, because folder ids and asset ids are indistinguishable integers. If these are asset ids, use media_delete_assets instead; otherwise the folders may already be gone. Use media_list_folders to discover valid folder ids.`;
+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. */ 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 — 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 — use media_list_assets to discover valid asset ids.';
+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.
+ */ const MCP_MOVE_ASSETS_ID_FAILED = (cause)=>`Moving this asset failed: ${cause}. This is not a problem with the id itself — the asset exists and this token may edit it — so retrying may succeed. Any assets listed under \`moved\` were still moved.`;
+/**
+ * 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.
+ */ 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 — 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.';
+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.
+ */ const MCP_DELETE_ASSETS_ID_FAILED = (cause)=>`Deleting this asset failed: ${cause}. The asset may be partially removed — re-read it with media_get_asset before retrying. Any assets listed under \`deleted\` are gone for good.`;
+
+export { MCP_DELETE_ASSETS_ID_FAILED, MCP_DELETE_ASSETS_ID_FORBIDDEN, MCP_DELETE_ASSETS_ID_NOT_FOUND, MCP_DELETE_FOLDER_UNRESOLVED_IDS, MCP_FOLDER_MOVE_INTO_SELF, MCP_FOLDER_NAME_TAKEN, MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND, MCP_MOVE_ASSETS_ID_FAILED, MCP_MOVE_ASSETS_ID_FORBIDDEN, MCP_MOVE_ASSETS_ID_NOT_FOUND, MCP_NOT_FOUND_ASSET, MCP_NOT_FOUND_FOLDER, MCP_PARENT_FOLDER_NOT_FOUND, MCP_UPDATE_ASSET_NO_FIELDS };
+//# sourceMappingURL=constants.mjs.map

package/dist/server/mcp/handlers/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","sources":["../../../../server/src/mcp/handlers/constants.ts"],"sourcesContent":["export const MCP_NOT_FOUND_ASSET = 'Media asset not found.';\n\nexport const MCP_UPDATE_ASSET_NO_FIELDS =\n  '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.';\n\nexport const MCP_NOT_FOUND_FOLDER = 'Media folder not found.';\n\nexport const MCP_FOLDER_NAME_TAKEN =\n  'A folder with this name already exists in the same parent folder. Folder names must be unique among siblings.';\n\nexport const MCP_PARENT_FOLDER_NOT_FOUND =\n  'The parent folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.';\n\nexport const MCP_FOLDER_MOVE_INTO_SELF =\n  'A folder cannot be moved into itself or into one of its own descendants.';\n\n/**\n * Returned when `media_delete_folder` is handed any id that does not resolve to a folder.\n *\n * Names the offending ids, because the call rejects as a whole: the agent has to know which\n * entries to drop or correct, and cannot infer that from a generic failure. Folder ids and\n * asset ids are indistinguishable integers, so an asset id is the likeliest cause and is named\n * first — but a deleted or never-existent folder id looks the same from here, so the message\n * covers both rather than asserting one.\n */\nexport const MCP_DELETE_FOLDER_UNRESOLVED_IDS = (ids: number[]) =>\n  `These ids do not match any media folder: ${ids.join(', ')}. Nothing was deleted — media_delete_folder rejects the whole request rather than deleting the folders that did match, because folder ids and asset ids are indistinguishable integers. If these are asset ids, use media_delete_assets instead; otherwise the folders may already be gone. Use media_list_folders to discover valid folder ids.`;\n\nexport const MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND =\n  'The destination folder does not exist. Use media_list_folders to discover valid folder ids, or pass null for the media library root.';\n\n/** Per-id `failed` reasons for `media_move_assets`. Both are per asset, so the wording names the id's fate, not the call's. */\nexport const MCP_MOVE_ASSETS_ID_NOT_FOUND =\n  'No media asset has this id, so nothing was moved for it. If this is a folder id, use media_move_folder — 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 — use media_list_assets to discover valid asset ids.';\n\nexport const MCP_MOVE_ASSETS_ID_FORBIDDEN =\n  'This token is not allowed to edit this asset. A permission condition on plugin::upload.assets.update excludes it.';\n\n/**\n * Returned when the move of one asset failed for a reason that is not a missing asset or a\n * permission denial — a DB error, say, or an upload-provider fault.\n *\n * Reported per id rather than thrown: a tool error carries no `structuredContent`, so throwing\n * would discard the report naming the assets that had already moved in the same call.\n * `cause` is the underlying message, kept verbatim so the real fault stays legible.\n */\nexport const MCP_MOVE_ASSETS_ID_FAILED = (cause: string) =>\n  `Moving this asset failed: ${cause}. This is not a problem with the id itself — the asset exists and this token may edit it — so retrying may succeed. Any assets listed under \\`moved\\` were still moved.`;\n\n/**\n * Per-id `failed` reasons for `media_delete_assets`, and the dry-run's `failed` reason.\n *\n * Reported per id rather than thrown, because a delete is irreversible: an error carries no\n * `structuredContent`, so throwing on the third id would discard the report saying the first\n * two are already gone — and no re-read can recover what was deleted.\n */\nexport const MCP_DELETE_ASSETS_ID_NOT_FOUND =\n  'No media asset has this id, so nothing was deleted for it. If this is a folder id, use media_delete_folder — 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.';\n\nexport const MCP_DELETE_ASSETS_ID_FORBIDDEN =\n  'This token is not allowed to delete this asset. A permission condition on plugin::upload.assets.update excludes it.';\n\n/**\n * Returned when the deletion of one asset failed for a reason that is not a missing asset or a\n * permission denial — a DB error, say, or an upload-provider fault.\n *\n * `cause` is the underlying message, kept verbatim so the real fault stays legible. The asset\n * may be half-removed (the provider file gone, the row still present, or the reverse), so the\n * wording tells the agent to re-read rather than assume either outcome.\n */\nexport const MCP_DELETE_ASSETS_ID_FAILED = (cause: string) =>\n  `Deleting this asset failed: ${cause}. The asset may be partially removed — re-read it with media_get_asset before retrying. Any assets listed under \\`deleted\\` are gone for good.`;\n"],"names":["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","ids","join","MCP_MOVE_ASSETS_DESTINATION_NOT_FOUND","MCP_MOVE_ASSETS_ID_NOT_FOUND","MCP_MOVE_ASSETS_ID_FORBIDDEN","MCP_MOVE_ASSETS_ID_FAILED","cause","MCP_DELETE_ASSETS_ID_NOT_FOUND","MCP_DELETE_ASSETS_ID_FORBIDDEN","MCP_DELETE_ASSETS_ID_FAILED"],"mappings":"AAAO,MAAMA,sBAAsB;AAE5B,MAAMC,6BACX;AAEK,MAAMC,uBAAuB;AAE7B,MAAMC,wBACX;AAEK,MAAMC,8BACX;AAEK,MAAMC,4BACX;AAEF;;;;;;;;AAQC,IACM,MAAMC,gCAAAA,GAAmC,CAACC,MAC/C,CAAC,yCAAyC,EAAEA,GAAAA,CAAIC,IAAI,CAAC,IAAA,CAAA,CAAM,gVAAgV;AAEtY,MAAMC,wCACX;AAEF,gIACO,MAAMC,4BAAAA,GACX;AAEK,MAAMC,+BACX;AAEF;;;;;;;IAQO,MAAMC,yBAAAA,GAA4B,CAACC,KAAAA,GACxC,CAAC,0BAA0B,EAAEA,KAAAA,CAAM,uKAAuK;AAE5M;;;;;;IAOO,MAAMC,8BAAAA,GACX;AAEK,MAAMC,iCACX;AAEF;;;;;;;IAQO,MAAMC,2BAAAA,GAA8B,CAACH,KAAAA,GAC1C,CAAC,4BAA4B,EAAEA,KAAAA,CAAM,8IAA8I;;;;"}

package/dist/server/mcp/handlers/folder-handlers.js

@@ -0,0 +1,308 @@
+'use strict';
+
+var utils$1 = require('@strapi/utils');
+var ambientInstance = require('../ambient-instance.js');
+var constants$1 = require('../../constants.js');
+var folders = require('../../controllers/utils/folders.js');
+var permissions = require('../permissions.js');
+var sanitizeMedia = require('../sanitizers/sanitize-media.js');
+var constants = require('./constants.js');
+var utils = require('../utils.js');
+
+/**
+ * `withParent` populates the parent relation in the same round trip. Rename needs the parent id
+ * to scope its sibling-uniqueness check, so it would otherwise read the same row twice; the
+ * subtree and cascade callers do not, and skip the join.
+ */ const findFolderById = async (strapi, id, { withParent = false } = {})=>strapi.db.query(constants$1.FOLDER_MODEL_UID).findOne({
+        select: [
+            'id',
+            'name',
+            'path'
+        ],
+        where: {
+            id
+        },
+        ...withParent ? {
+            populate: {
+                parent: {
+                    select: [
+                        'id'
+                    ]
+                }
+            }
+        } : {}
+    });
+/**
+ * Re-reads a folder with its parent populated, so the write tools can echo back the same shape
+ * regardless of what the service returned.
+ *
+ * `folder.update()` resolves the row it wrote without the `parent` relation, and on a pure rename
+ * it never touches the join table at all — so the parent has to be read back to be reported.
+ */ const readFolderForOutput = async (strapi, id, fallback)=>{
+    const row = await strapi.db.query(constants$1.FOLDER_MODEL_UID).findOne({
+        where: {
+            id
+        },
+        populate: {
+            parent: {
+                select: [
+                    'id',
+                    'name'
+                ]
+            }
+        }
+    });
+    // The write succeeded, so report it even if the read-back comes back empty rather than
+    // failing a completed operation on a follow-up query.
+    return sanitizeMedia.sanitizeMediaFolder(row ?? fallback);
+};
+/**
+ * Replicates the admin folder controller's `parent` check: a named parent must exist.
+ *
+ * null is the media library root and always valid, so only a numeric id is looked up.
+ */ const assertParentExists = async (strapi, parent)=>{
+    if (parent === null || parent === undefined) {
+        return;
+    }
+    const exists = await ambientInstance.getFolderService(strapi).exists({
+        id: parent
+    });
+    if (!exists) {
+        throw new utils$1.errors.ValidationError(constants.MCP_PARENT_FOLDER_NOT_FOUND);
+    }
+};
+/**
+ * Replicates `is-folder-unique` from the admin folder validation: a folder name must be unique
+ * among its siblings.
+ *
+ * `excludeId` is the folder being renamed — without it a rename to the folder's current name
+ * would collide with itself.
+ */ const assertNameAvailable = async (strapi, name, parent, excludeId)=>{
+    const filters = {
+        name,
+        parent: parent ?? null
+    };
+    if (excludeId !== undefined) {
+        filters.id = {
+            $ne: excludeId
+        };
+    }
+    if (await ambientInstance.getFolderService(strapi).exists(filters)) {
+        throw new utils$1.errors.ValidationError(constants.MCP_FOLDER_NAME_TAKEN);
+    }
+};
+/**
+ * Replicates `dont-move-inside-self`: a folder cannot become its own descendant.
+ *
+ * Without this the folder service would rewrite the subtree's materialized paths into a cycle,
+ * orphaning every descendant — the tree has no root to walk back to afterwards.
+ */ const assertNotMovedIntoOwnSubtree = async (strapi, folder, parent)=>{
+    if (parent === null) {
+        return;
+    }
+    const destination = await findFolderById(strapi, parent);
+    // A missing destination is already reported by `assertParentExists`.
+    if (destination === null) {
+        return;
+    }
+    if (folders.isFolderOrChild(destination, folder)) {
+        throw new utils$1.errors.ValidationError(constants.MCP_FOLDER_MOVE_INTO_SELF);
+    }
+};
+/**
+ * Counts the folders and files a `deleteByIds` of these paths would remove.
+ *
+ * Mirrors the two `$or` predicates in `folder.deleteByIds` exactly — self path plus the
+ * `${path}/` prefix — so the dry-run number is the same set the destructive branch acts on
+ * rather than an independent estimate that could drift from it.
+ */ const countCascade = async (strapi, paths)=>{
+    const pathPredicate = (field)=>({
+            $or: paths.flatMap((path)=>[
+                    {
+                        [field]: {
+                            $eq: path
+                        }
+                    },
+                    {
+                        [field]: {
+                            $startsWith: `${path}/`
+                        }
+                    }
+                ])
+        });
+    const [totalFolderNumber, totalFileNumber] = await Promise.all([
+        strapi.db.query(constants$1.FOLDER_MODEL_UID).count({
+            where: pathPredicate('path')
+        }),
+        strapi.db.query(constants$1.FILE_MODEL_UID).count({
+            where: pathPredicate('folderPath')
+        })
+    ]);
+    return {
+        totalFolderNumber,
+        totalFileNumber
+    };
+};
+/**
+ * `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`.
+ */ const createMediaCreateFolderHandler = (strapi, context)=>{
+    ambientInstance.assertAmbientInstance(strapi);
+    return async ({ args })=>{
+        const { name, parent = null } = args;
+        permissions.assertMediaPermission(strapi, context, constants$1.ACTIONS.create, constants$1.FOLDER_MODEL_UID);
+        await assertParentExists(strapi, parent);
+        await assertNameAvailable(strapi, name, parent);
+        const created = await ambientInstance.getFolderService(strapi).create({
+            name,
+            parent
+        }, {
+            user: context.user
+        });
+        return utils.ok({
+            data: await readFolderForOutput(strapi, created.id, created)
+        });
+    };
+};
+/**
+ * `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.
+ */ const createMediaRenameFolderHandler = (strapi, context)=>{
+    ambientInstance.assertAmbientInstance(strapi);
+    return async ({ args })=>{
+        const { id, name } = args;
+        permissions.assertMediaPermission(strapi, context, constants$1.ACTIONS.update, constants$1.FOLDER_MODEL_UID);
+        const folder = await findFolderById(strapi, id, {
+            withParent: true
+        });
+        if (folder === null) {
+            throw new utils$1.errors.NotFoundError(constants.MCP_NOT_FOUND_FOLDER);
+        }
+        // Siblings are the folders sharing this folder's parent, so uniqueness is checked against
+        // the current location — a rename never changes it.
+        const parentId = folder.parent?.id ?? null;
+        await assertNameAvailable(strapi, name, parentId, id);
+        // `parent` is omitted on purpose — see the note above.
+        const renamed = await ambientInstance.getFolderService(strapi).update(id, {
+            name
+        }, {
+            user: context.user
+        });
+        return utils.ok({
+            data: await readFolderForOutput(strapi, id, renamed ?? {
+                ...folder,
+                name
+            })
+        });
+    };
+};
+/**
+ * `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.
+ */ const createMediaMoveFolderHandler = (strapi, context)=>{
+    ambientInstance.assertAmbientInstance(strapi);
+    return async ({ args })=>{
+        const { id, parent } = args;
+        permissions.assertMediaPermission(strapi, context, constants$1.ACTIONS.update, constants$1.FOLDER_MODEL_UID);
+        const folder = await findFolderById(strapi, id);
+        if (folder === null) {
+            throw new utils$1.errors.NotFoundError(constants.MCP_NOT_FOUND_FOLDER);
+        }
+        await assertParentExists(strapi, parent);
+        await assertNotMovedIntoOwnSubtree(strapi, folder, parent);
+        // A folder keeps its name across a move, so uniqueness must hold in the destination.
+        await assertNameAvailable(strapi, folder.name, parent, id);
+        const moved = await ambientInstance.getFolderService(strapi).update(id, {
+            name: folder.name,
+            parent
+        }, {
+            user: context.user
+        });
+        return utils.ok({
+            data: await readFolderForOutput(strapi, id, moved ?? folder)
+        });
+    };
+};
+/**
+ * `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`.
+ */ const createMediaDeleteFolderHandler = (strapi, context)=>{
+    ambientInstance.assertAmbientInstance(strapi);
+    return async ({ args })=>{
+        const { ids, dryRun = true } = args;
+        permissions.assertMediaPermission(strapi, context, constants$1.ACTIONS.update, constants$1.FOLDER_MODEL_UID);
+        const matched = await strapi.db.query(constants$1.FOLDER_MODEL_UID).findMany({
+            select: [
+                'id',
+                'name',
+                'path'
+            ],
+            where: {
+                id: {
+                    $in: ids
+                }
+            }
+        });
+        /**
+     * All-or-nothing: any id that does not resolve to a folder rejects the whole call, before
+     * anything is deleted.
+     *
+     * Folder ids and asset ids are indistinguishable integers, so a list mixing the two is the
+     * mistake this tool exists to catch — and deleting the folders that did match while
+     * reporting the rest back would be exactly the silent confusion that requirement forbids,
+     * with the cascade already gone by the time the agent reads the response.
+     *
+     * An unresolvable id cannot be diagnosed further from here (an asset id and a deleted
+     * folder id look identical), and it does not need to be: either way it is unusable.
+     *
+     * The dry run rejects on the same rule. A preview that reported a cascade for a request the
+     * executing call would refuse is worse than no preview — it is a confirmation an agent
+     * cannot act on.
+     */ const matchedIds = new Set(matched.map((folder)=>folder.id));
+        const unresolvedIds = ids.filter((id)=>matchedIds.has(id) === false);
+        if (unresolvedIds.length > 0) {
+            throw new utils$1.errors.ValidationError(constants.MCP_DELETE_FOLDER_UNRESOLVED_IDS(unresolvedIds));
+        }
+        const folders = matched.map((folder)=>sanitizeMedia.sanitizeMediaFolder(folder));
+        if (dryRun) {
+            const counts = await countCascade(strapi, matched.map((folder)=>folder.path));
+            return utils.ok({
+                dryRun: true,
+                folders,
+                ...counts
+            });
+        }
+        const { totalFolderNumber, totalFileNumber } = await ambientInstance.getFolderService(strapi).deleteByIds(matched.map((folder)=>folder.id));
+        return utils.ok({
+            dryRun: false,
+            folders,
+            totalFolderNumber,
+            totalFileNumber
+        });
+    };
+};
+
+exports.createMediaCreateFolderHandler = createMediaCreateFolderHandler;
+exports.createMediaDeleteFolderHandler = createMediaDeleteFolderHandler;
+exports.createMediaMoveFolderHandler = createMediaMoveFolderHandler;
+exports.createMediaRenameFolderHandler = createMediaRenameFolderHandler;
+//# sourceMappingURL=folder-handlers.js.map

package/dist/server/mcp/handlers/folder-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-handlers.js","sources":["../../../../server/src/mcp/handlers/folder-handlers.ts"],"sourcesContent":["import { errors } from '@strapi/utils';\nimport type { Core, Modules } from '@strapi/types';\n\nimport { assertAmbientInstance, getFolderService } from '../ambient-instance';\nimport { ACTIONS, FOLDER_MODEL_UID, FILE_MODEL_UID } from '../../constants';\nimport { isFolderOrChild } from '../../controllers/utils/folders';\nimport { assertMediaPermission } from '../permissions';\nimport { sanitizeMediaFolder } from '../sanitizers/sanitize-media';\nimport {\n  MCP_NOT_FOUND_FOLDER,\n  MCP_FOLDER_NAME_TAKEN,\n  MCP_PARENT_FOLDER_NOT_FOUND,\n  MCP_FOLDER_MOVE_INTO_SELF,\n  MCP_DELETE_FOLDER_UNRESOLVED_IDS,\n} from './constants';\nimport { ok } from '../utils';\n\nimport type { Folder } from '../../types';\n\n// Arg types are type-level only: the MCP SDK validates `args` against the tool's strict Zod\n// input schema before the handler runs, so unknown keys never reach here.\ntype CreateFolderArgs = {\n  name: string;\n  parent?: number | null;\n};\n\ntype RenameFolderArgs = {\n  id: number;\n  name: string;\n};\n\ntype MoveFolderArgs = {\n  id: number;\n  parent: number | null;\n};\n\ntype DeleteFolderArgs = {\n  ids: number[];\n  dryRun?: boolean;\n};\n\n/** The folder fields the handlers need; `path` drives the cascade and subtree checks. */\ntype FolderRow = Pick<Folder, 'id' | 'name' | 'path'>;\n\n/**\n * `withParent` populates the parent relation in the same round trip. Rename needs the parent id\n * to scope its sibling-uniqueness check, so it would otherwise read the same row twice; the\n * subtree and cascade callers do not, and skip the join.\n */\nconst findFolderById = async (\n  strapi: Core.Strapi,\n  id: number,\n  { withParent = false }: { withParent?: boolean } = {}\n): Promise<(FolderRow & { parent?: { id: number } | null }) | null> =>\n  strapi.db.query(FOLDER_MODEL_UID).findOne({\n    select: ['id', 'name', 'path'],\n    where: { id },\n    ...(withParent ? { populate: { parent: { select: ['id'] } } } : {}),\n  });\n\n/**\n * Re-reads a folder with its parent populated, so the write tools can echo back the same shape\n * regardless of what the service returned.\n *\n * `folder.update()` resolves the row it wrote without the `parent` relation, and on a pure rename\n * it never touches the join table at all — so the parent has to be read back to be reported.\n */\nconst readFolderForOutput = async (\n  strapi: Core.Strapi,\n  id: number,\n  fallback: Record<string, unknown>\n) => {\n  const row = await strapi.db.query(FOLDER_MODEL_UID).findOne({\n    where: { id },\n    populate: { parent: { select: ['id', 'name'] } },\n  });\n\n  // The write succeeded, so report it even if the read-back comes back empty rather than\n  // failing a completed operation on a follow-up query.\n  return sanitizeMediaFolder(row ?? fallback);\n};\n\n/**\n * Replicates the admin folder controller's `parent` check: a named parent must exist.\n *\n * null is the media library root and always valid, so only a numeric id is looked up.\n */\nconst assertParentExists = async (strapi: Core.Strapi, parent: number | null | undefined) => {\n  if (parent === null || parent === undefined) {\n    return;\n  }\n\n  const exists = await getFolderService(strapi).exists({ id: parent });\n\n  if (!exists) {\n    throw new errors.ValidationError(MCP_PARENT_FOLDER_NOT_FOUND);\n  }\n};\n\n/**\n * Replicates `is-folder-unique` from the admin folder validation: a folder name must be unique\n * among its siblings.\n *\n * `excludeId` is the folder being renamed — without it a rename to the folder's current name\n * would collide with itself.\n */\nconst assertNameAvailable = async (\n  strapi: Core.Strapi,\n  name: string,\n  parent: number | null,\n  excludeId?: number\n) => {\n  const filters: Record<string, unknown> = { name, parent: parent ?? null };\n\n  if (excludeId !== undefined) {\n    filters.id = { $ne: excludeId };\n  }\n\n  if (await getFolderService(strapi).exists(filters)) {\n    throw new errors.ValidationError(MCP_FOLDER_NAME_TAKEN);\n  }\n};\n\n/**\n * Replicates `dont-move-inside-self`: a folder cannot become its own descendant.\n *\n * Without this the folder service would rewrite the subtree's materialized paths into a cycle,\n * orphaning every descendant — the tree has no root to walk back to afterwards.\n */\nconst assertNotMovedIntoOwnSubtree = async (\n  strapi: Core.Strapi,\n  folder: FolderRow,\n  parent: number | null\n) => {\n  if (parent === null) {\n    return;\n  }\n\n  const destination = await findFolderById(strapi, parent);\n\n  // A missing destination is already reported by `assertParentExists`.\n  if (destination === null) {\n    return;\n  }\n\n  if (isFolderOrChild(destination, folder)) {\n    throw new errors.ValidationError(MCP_FOLDER_MOVE_INTO_SELF);\n  }\n};\n\n/**\n * Counts the folders and files a `deleteByIds` of these paths would remove.\n *\n * Mirrors the two `$or` predicates in `folder.deleteByIds` exactly — self path plus the\n * `${path}/` prefix — so the dry-run number is the same set the destructive branch acts on\n * rather than an independent estimate that could drift from it.\n */\nconst countCascade = async (strapi: Core.Strapi, paths: string[]) => {\n  const pathPredicate = (field: string) => ({\n    $or: paths.flatMap((path) => [\n      { [field]: { $eq: path } },\n      { [field]: { $startsWith: `${path}/` } },\n    ]),\n  });\n\n  const [totalFolderNumber, totalFileNumber] = await Promise.all([\n    strapi.db.query(FOLDER_MODEL_UID).count({ where: pathPredicate('path') }),\n    strapi.db.query(FILE_MODEL_UID).count({ where: pathPredicate('folderPath') }),\n  ]);\n\n  return { totalFolderNumber, totalFileNumber };\n};\n\n/**\n * `media_create_folder` — a new folder, optionally nested.\n *\n * Gated on `plugin::upload.assets.create` and mirrors `POST /upload/folders`: the same\n * permission, the same uniqueness and parent-existence validation, the same `folder.create()`\n * call, and the same `createdBy` attribution from the session user.\n *\n * `create` rather than the `update` the other folder tools use: creating a folder is the one\n * folder operation whose admin route gates on `assets.create`.\n */\nexport const createMediaCreateFolderHandler = (\n  strapi: Core.Strapi,\n  context: Modules.MCP.McpHandlerContext\n) => {\n  assertAmbientInstance(strapi);\n\n  return async ({\n    args,\n  }: {\n    args: Record<string, unknown>;\n  }): Promise<Modules.MCP.McpToolHandlerReturn> => {\n    const { name, parent = null } = args as CreateFolderArgs;\n\n    assertMediaPermission(strapi, context, ACTIONS.create, FOLDER_MODEL_UID);\n\n    await assertParentExists(strapi, parent);\n    await assertNameAvailable(strapi, name, parent);\n\n    const created = await getFolderService(strapi).create({ name, parent }, { user: context.user });\n\n    return ok({ data: await readFolderForOutput(strapi, created.id, created) });\n  };\n};\n\n/**\n * `media_rename_folder` — changes a folder's name and nothing else.\n *\n * Deliberately does not forward `parent` to `folder.update()`: the service branches on\n * `isUndefined(parent)`, and the name-only branch skips the transaction that rewrites descendant\n * paths. Passing the folder's existing parent would take the move branch and rewrite the whole\n * subtree to compute the identical paths.\n */\nexport const createMediaRenameFolderHandler = (\n  strapi: Core.Strapi,\n  context: Modules.MCP.McpHandlerContext\n) => {\n  assertAmbientInstance(strapi);\n\n  return async ({\n    args,\n  }: {\n    args: Record<string, unknown>;\n  }): Promise<Modules.MCP.McpToolHandlerReturn> => {\n    const { id, name } = args as RenameFolderArgs;\n\n    assertMediaPermission(strapi, context, ACTIONS.update, FOLDER_MODEL_UID);\n\n    const folder = await findFolderById(strapi, id, { withParent: true });\n\n    if (folder === null) {\n      throw new errors.NotFoundError(MCP_NOT_FOUND_FOLDER);\n    }\n\n    // Siblings are the folders sharing this folder's parent, so uniqueness is checked against\n    // the current location — a rename never changes it.\n    const parentId = folder.parent?.id ?? null;\n\n    await assertNameAvailable(strapi, name, parentId, id);\n\n    // `parent` is omitted on purpose — see the note above.\n    const renamed = await getFolderService(strapi).update(id, { name }, { user: context.user });\n\n    return ok({ data: await readFolderForOutput(strapi, id, renamed ?? { ...folder, name }) });\n  };\n};\n\n/**\n * `media_move_folder` — re-parents a folder, carrying its whole subtree with it.\n *\n * `folder.update()` recalculates the materialized `path` of every descendant folder and the\n * `folderPath` of every contained file inside a transaction, so the move is atomic and no\n * separate bookkeeping is needed here.\n */\nexport const createMediaMoveFolderHandler = (\n  strapi: Core.Strapi,\n  context: Modules.MCP.McpHandlerContext\n) => {\n  assertAmbientInstance(strapi);\n\n  return async ({\n    args,\n  }: {\n    args: Record<string, unknown>;\n  }): Promise<Modules.MCP.McpToolHandlerReturn> => {\n    const { id, parent } = args as MoveFolderArgs;\n\n    assertMediaPermission(strapi, context, ACTIONS.update, FOLDER_MODEL_UID);\n\n    const folder = await findFolderById(strapi, id);\n\n    if (folder === null) {\n      throw new errors.NotFoundError(MCP_NOT_FOUND_FOLDER);\n    }\n\n    await assertParentExists(strapi, parent);\n    await assertNotMovedIntoOwnSubtree(strapi, folder, parent);\n\n    // A folder keeps its name across a move, so uniqueness must hold in the destination.\n    await assertNameAvailable(strapi, folder.name, parent, id);\n\n    const moved = await getFolderService(strapi).update(\n      id,\n      { name: folder.name, parent },\n      { user: context.user }\n    );\n\n    return ok({ data: await readFolderForOutput(strapi, id, moved ?? folder) });\n  };\n};\n\n/**\n * `media_delete_folder` — previews or performs a cascading folder deletion.\n *\n * Two branches behind one tool, because the preview and the deletion must agree on what the\n * cascade covers; splitting them across tools would let the two drift apart, and an agent could\n * reach the destructive one without ever seeing a count.\n *\n * `dryRun` defaults to true (see the input schema): omitting the flag previews, and deleting\n * takes an explicit `dryRun: false`.\n */\nexport const createMediaDeleteFolderHandler = (\n  strapi: Core.Strapi,\n  context: Modules.MCP.McpHandlerContext\n) => {\n  assertAmbientInstance(strapi);\n\n  return async ({\n    args,\n  }: {\n    args: Record<string, unknown>;\n  }): Promise<Modules.MCP.McpToolHandlerReturn> => {\n    const { ids, dryRun = true } = args as DeleteFolderArgs;\n\n    assertMediaPermission(strapi, context, ACTIONS.update, FOLDER_MODEL_UID);\n\n    const matched: FolderRow[] = await strapi.db.query(FOLDER_MODEL_UID).findMany({\n      select: ['id', 'name', 'path'],\n      where: { id: { $in: ids } },\n    });\n\n    /**\n     * All-or-nothing: any id that does not resolve to a folder rejects the whole call, before\n     * anything is deleted.\n     *\n     * Folder ids and asset ids are indistinguishable integers, so a list mixing the two is the\n     * mistake this tool exists to catch — and deleting the folders that did match while\n     * reporting the rest back would be exactly the silent confusion that requirement forbids,\n     * with the cascade already gone by the time the agent reads the response.\n     *\n     * An unresolvable id cannot be diagnosed further from here (an asset id and a deleted\n     * folder id look identical), and it does not need to be: either way it is unusable.\n     *\n     * The dry run rejects on the same rule. A preview that reported a cascade for a request the\n     * executing call would refuse is worse than no preview — it is a confirmation an agent\n     * cannot act on.\n     */\n    const matchedIds = new Set(matched.map((folder) => folder.id));\n    const unresolvedIds = ids.filter((id) => matchedIds.has(id) === false);\n\n    if (unresolvedIds.length > 0) {\n      throw new errors.ValidationError(MCP_DELETE_FOLDER_UNRESOLVED_IDS(unresolvedIds));\n    }\n\n    const folders = matched.map((folder) => sanitizeMediaFolder(folder));\n\n    if (dryRun) {\n      const counts = await countCascade(\n        strapi,\n        matched.map((folder) => folder.path)\n      );\n\n      return ok({ dryRun: true, folders, ...counts });\n    }\n\n    const { totalFolderNumber, totalFileNumber } = await getFolderService(strapi).deleteByIds(\n      matched.map((folder) => folder.id)\n    );\n\n    return ok({\n      dryRun: false,\n      folders,\n      totalFolderNumber,\n      totalFileNumber,\n    });\n  };\n};\n"],"names":["findFolderById","strapi","id","withParent","db","query","FOLDER_MODEL_UID","findOne","select","where","populate","parent","readFolderForOutput","fallback","row","sanitizeMediaFolder","assertParentExists","undefined","exists","getFolderService","errors","ValidationError","MCP_PARENT_FOLDER_NOT_FOUND","assertNameAvailable","name","excludeId","filters","$ne","MCP_FOLDER_NAME_TAKEN","assertNotMovedIntoOwnSubtree","folder","destination","isFolderOrChild","MCP_FOLDER_MOVE_INTO_SELF","countCascade","paths","pathPredicate","field","$or","flatMap","path","$eq","$startsWith","totalFolderNumber","totalFileNumber","Promise","all","count","FILE_MODEL_UID","createMediaCreateFolderHandler","context","assertAmbientInstance","args","assertMediaPermission","ACTIONS","create","created","user","ok","data","createMediaRenameFolderHandler","update","NotFoundError","MCP_NOT_FOUND_FOLDER","parentId","renamed","createMediaMoveFolderHandler","moved","createMediaDeleteFolderHandler","ids","dryRun","matched","findMany","$in","matchedIds","Set","map","unresolvedIds","filter","has","length","MCP_DELETE_FOLDER_UNRESOLVED_IDS","folders","counts","deleteByIds"],"mappings":"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"}