@ezmodo/mcp-server 0.13.0

package/handlers/epics.js

@@ -0,0 +1,190 @@
+/**
+ * Epic Handlers
+ * Handler functions for epic-related MCP tools
+ *
+ * Project-First Hierarchy: Epics belong to projects (required),
+ * with optional component grouping and milestone linking.
+ *
+ * Auto-assignment: When creating epics, automatically applies matching tags
+ * based on content analysis against the local project cache.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+import { resolveEpicAutoAssign } from '../lib/auto-assign.js';
+import { buildEpicUrl } from '../lib/web-url.js';
+import { getLogger } from '../lib/logger.js';
+import { attachLinks } from '../lib/links-at-create.js';
+import { normalizeChangedFiles } from '../lib/changed-files.js';
+
+/**
+ * Apply tags to a newly created entity via bulkTagEntities.
+ * Non-fatal — logs errors but doesn't throw.
+ */
+async function applyAutoTags(organizationId, entityType, entityId, tagIds) {
+  if (!organizationId || !tagIds?.length || !entityId) return;
+  try {
+    await callZephlyAPI('mcpBulkTagEntities', {
+      organizationId,
+      tagIds,
+      entities: [{ entityType, entityId }],
+      operation: 'add',
+    });
+  } catch (err) {
+    getLogger().warn('Auto-tag failed', { entityType, entityId, error: err.message });
+  }
+}
+
+/**
+ * Flatten the nested-task result into the fields an agent acts on (#2247).
+ *
+ * Mutates `result` in place, mirroring create_tasks: failures are surfaced as
+ * their own list because an agent scanning a 40-entry array can miss three error
+ * fields, and re-running the create is the costly mistake — it would make a
+ * second epic on top of duplicating the tasks that succeeded.
+ */
+function summarizeNestedTasks(result) {
+  if (!result) return;
+  const created = result.tasks?.created ?? 0;
+  const failed = result.tasks?.failed ?? 0;
+  const results = result.tasks?.results ?? [];
+
+  if (result.tasksError) {
+    result.message = `Epic created, but no tasks were: ${result.tasksError}. ` +
+      'The epic exists — send the tasks with create_tasks rather than creating the epic again.';
+    return;
+  }
+
+  result.message = failed === 0
+    ? `Created the epic and ${created} task${created === 1 ? '' : 's'} in one request.`
+    : `Epic created with ${created} of ${created + failed} tasks. ${failed} failed — the epic and the ` +
+      'successful tasks exist, so retry ONLY the items listed in failures with create_tasks.';
+
+  if (failed > 0) {
+    result.failures = results
+      .filter((r) => r.error)
+      .map((r) => ({ index: r.index, title: r.title, error: r.error }));
+  }
+  if (created > 0) {
+    result.taskNumbers = results.filter((r) => r.taskNumber).map((r) => r.taskNumber);
+  }
+}
+
+/**
+ * Dispatch manage_epic actions to the appropriate handler
+ */
+export async function manageEpic(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createEpic(params);
+  case 'update': return updateEpic(params);
+  case 'generate_how_it_works': return generateEpicHowItWorks(params);
+  case 'apply_how_it_works': return applyEpicHowItWorks(params);
+  default: throw new Error(
+    `Unknown action: ${action}. Expected create, update, generate_how_it_works, or apply_how_it_works.`,
+  );
+  }
+}
+
+// (Re)generate the epic's grounded, source-attributed "how it works" living
+// description (E-237 #2382). An epic's reality is its tasks — their status,
+// captured decisions and linked commits — and its intent is the epic description
+// plus the decisions reached by walking those tasks (settled model A, #2376).
+// Server-side: one model call, AI-quota gated.
+async function generateEpicHowItWorks({ epicId }) {
+  return callZephlyAPI('mcpGenerateEpicHowItWorks', { epicId });
+}
+
+// Apply (persist) a LOCAL-agent-authored "how it works" for an epic (BYO-AI,
+// E-190). Cited sources are validated server-side against the real grounded
+// context before saving; no model call, so no AI quota is spent.
+async function applyEpicHowItWorks({ epicId, markdown, sources }) {
+  return callZephlyAPI('mcpApplyEpicHowItWorks', { epicId, markdown, sources });
+}
+
+async function createEpic(args) {
+  // `links` is applied by the MCP layer after the epic exists (E-225).
+  const { links, tasks, ...createArgs } = args;
+  const { title, description } = createArgs;
+
+  // Checked client-side too so an oversized breakdown fails immediately with
+  // actionable advice rather than spending a request to be rejected.
+  if (tasks?.length > 40) {
+    throw new Error(
+      `cannot create ${tasks.length} tasks with an epic in one call (limit 40) — ` +
+      'create the epic with the first 40, then send the rest with create_tasks',
+    );
+  }
+
+  // An epic with its breakdown goes to the composing endpoint (#2247) so the
+  // whole thing is one request; without tasks nothing changes. Everything below
+  // this line — auto-tags, links, web URL — acts on the EPIC and so is identical
+  // either way.
+  const result = tasks?.length
+    ? await callZephlyAPI('mcpCreateEpicWithTasks', {
+      ...createArgs,
+      tasks: tasks.map(({ changedFiles, linkedFiles, ...rest }) => ({
+        ...rest,
+        // Accept the same two spellings as manage_task, matching create_tasks.
+        linkedFiles: normalizeChangedFiles(changedFiles, linkedFiles),
+      })),
+    })
+    : await callZephlyAPI('mcpCreateEpic', createArgs);
+
+  if (tasks?.length) summarizeNestedTasks(result);
+
+  // Auto-apply matching tags (non-fatal)
+  const autoAssign = await resolveEpicAutoAssign(title, description);
+  if (autoAssign?.matchedTags?.length && result?.epicId) {
+    await applyAutoTags(
+      autoAssign.organizationId,
+      'epic',
+      result.epicId,
+      autoAssign.matchedTags.map((t) => t.id),
+    );
+    result.autoAssigned = {
+      tags: autoAssign.matchedTags.map((t) => t.name),
+    };
+  }
+
+  // Attach create-time links (E-225) — best effort, never fails the create.
+  await attachLinks(result, { sourceType: 'epic', sourceId: result?.epicId, links });
+
+  // Enrich with web URL
+  const webUrl = await buildEpicUrl(result?.epicNumber);
+  if (webUrl) result.webUrl = webUrl;
+
+  return result;
+}
+
+async function updateEpic(args) {
+  const result = await callZephlyAPI('mcpUpdateEpic', args);
+
+  // If the milestone is frozen and the operation was blocked, return guidance
+  if (result?.blocked) {
+    return {
+      blocked: true,
+      freezeType: result.freezeType,
+      milestoneId: result.milestoneId,
+      milestoneName: result.milestoneName,
+      message: `Milestone Frozen (${result.milestoneName || 'unknown'}, ${result.freezeType}): ${result.reason || 'No reason provided'}`,
+      suggestion: result.suggestion,
+    };
+  }
+
+  return result;
+}
+
+export async function searchEpics(args) {
+  return callZephlyAPI('mcpSearchEpics', args);
+}
+
+export async function listEpics(args) {
+  return callZephlyAPI('mcpListEpics', args);
+}
+
+export async function getEpic(args) {
+  const result = await callZephlyAPI('mcpGetEpic', args);
+  const webUrl = await buildEpicUrl(result?.epic?.epicNumber);
+  if (webUrl && result?.epic) result.epic.webUrl = webUrl;
+  return result;
+}

package/handlers/facts.js

@@ -0,0 +1,62 @@
+/**
+ * Fact Handlers
+ * Handler functions for fact-related MCP tools
+ *
+ * Facts are project-scoped knowledge entries for tracking:
+ * - Decisions and conventions
+ * - Reference information
+ * - Key context for humans and AI agents
+ *
+ * Write operations (create, update, delete) invalidate the cache.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+import { invalidateCacheSection } from '../lib/local-cache.js';
+
+/**
+ * Dispatch manage_fact actions to the appropriate handler
+ */
+export async function manageFact(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createFact(params);
+  case 'update': return updateFact(params);
+  case 'delete': return deleteFact(params);
+  default: throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+/**
+ * List facts for a project, optionally retrieving a single fact by ID.
+ */
+export async function listFacts(args) {
+  const { projectId, factId } = args;
+  return callZephlyAPI('mcpListFacts', { projectId, factId });
+}
+
+/**
+ * Create a new fact
+ */
+async function createFact(args) {
+  const result = await callZephlyAPI('mcpCreateFact', args);
+  await invalidateCacheSection('facts');
+  return result;
+}
+
+/**
+ * Update an existing fact
+ */
+async function updateFact(args) {
+  const result = await callZephlyAPI('mcpUpdateFact', args);
+  await invalidateCacheSection('facts');
+  return result;
+}
+
+/**
+ * Delete a fact
+ */
+async function deleteFact(args) {
+  const result = await callZephlyAPI('mcpDeleteFact', args);
+  await invalidateCacheSection('facts');
+  return result;
+}

package/handlers/feature-flags.js

@@ -0,0 +1,142 @@
+/**
+ * Feature Flag Handlers
+ * Handler functions for the Feature Flags MCP tools (E-149).
+ *
+ * Feature Flags are org-level (projectId nullable) PM-aware runtime gates that
+ * LINK to the feature(s) they gate via the generic link graph. These handlers are
+ * thin wrappers over /api/mcp/v1/feature-flags; dispatch, validation, prerequisite
+ * resolution, and evaluation happen server-side in core/featureflags.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+
+/**
+ * Dispatch manage_feature_flag actions.
+ */
+export async function manageFeatureFlag(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createFeatureFlag(params);
+  case 'update': return updateFeatureFlag(params);
+  case 'delete': return deleteFeatureFlag(params);
+  case 'transition': return transitionFeatureFlag(params);
+  case 'link': return linkFeatureFlagArtifact(params);
+  case 'unlink': return unlinkFeatureFlagArtifact(params);
+  case 'set_environment_config': return setFeatureFlagEnvironmentConfig(params);
+  default:
+    throw new Error(
+      `Unknown action: ${action}. Expected create, update, delete, transition, link, unlink, ` +
+      'or set_environment_config.');
+  }
+}
+
+/**
+ * Dispatch manage_environment actions (E-186 environment registry).
+ */
+export async function manageEnvironment(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'list': return listEnvironments(params);
+  case 'create': return callZephlyAPI('mcpCreateEnvironment', params);
+  case 'update': return callZephlyAPI('mcpUpdateEnvironment', params);
+  case 'delete': return callZephlyAPI('mcpDeleteEnvironment', { environmentId: params.environmentId });
+  case 'set_default': return callZephlyAPI('mcpSetDefaultEnvironment', { environmentId: params.environmentId });
+  default:
+    throw new Error(`Unknown action: ${action}. Expected list, create, update, delete, or set_default.`);
+  }
+}
+
+async function listEnvironments({ organizationId, projectId }) {
+  const params = { organizationId };
+  if (projectId) params.projectId = projectId;
+  return callZephlyAPI('mcpListEnvironments', params);
+}
+
+async function setFeatureFlagEnvironmentConfig({ flagId, environmentId, enabled, rolloutPercentage, defaultVariantId }) {
+  const body = { flagId, environmentId, enabled, rolloutPercentage };
+  if (defaultVariantId !== undefined) body.defaultVariantId = defaultVariantId;
+  return callZephlyAPI('mcpSetFlagEnvironmentConfig', body);
+}
+
+/**
+ * Retrieve a single flag by ID or by organizationId + key (optionally + links).
+ */
+export async function getFeatureFlag(args) {
+  const { includeLinks, flagId, organizationId, key } = args;
+
+  const params = {};
+  if (flagId) {
+    params.flagId = flagId;
+  } else if (organizationId && key) {
+    params.organizationId = organizationId;
+    params.key = key;
+  } else {
+    throw new Error('Provide flagId, or organizationId and key.');
+  }
+
+  const result = await callZephlyAPI('mcpGetFeatureFlag', params);
+  if (includeLinks) {
+    const id = flagId || result?.featureFlag?.id || result?.id;
+    if (id) {
+      const links = await callZephlyAPI('mcpListFeatureFlagLinks', { flagId: id });
+      result.links = links?.links ?? links;
+    }
+  }
+  return result;
+}
+
+/**
+ * List an org's flags (filtered), or the flags linked to an entity.
+ */
+export async function listFeatureFlags(args) {
+  const params = {};
+  if (args.organizationId) params.organizationId = args.organizationId;
+  if (args.linkedType && args.linkedId) {
+    params.linkedType = args.linkedType;
+    params.linkedId = args.linkedId;
+    return callZephlyAPI('mcpListFeatureFlags', params);
+  }
+  if (args.projectId) params.projectId = args.projectId;
+  if (args.status) params.status = args.status;
+  if (args.kind) params.kind = args.kind;
+  if (args.includeOrgWide != null) params.includeOrgWide = args.includeOrgWide;
+  if (args.limit != null) params.limit = args.limit;
+  return callZephlyAPI('mcpListFeatureFlags', params);
+}
+
+/**
+ * Evaluate a flag for a subject — debugging affordance from chat.
+ */
+export async function evaluateFeatureFlag(args) {
+  const params = { organizationId: args.organizationId, key: args.key };
+  if (args.subjectId) params.subjectId = args.subjectId;
+  if (args.environment) params.environment = args.environment;
+  if (args.attributes) params.attributes = args.attributes;
+  return callZephlyAPI('mcpEvaluateFeatureFlag', params);
+}
+
+// --- Private helpers ---
+
+async function createFeatureFlag(args) {
+  return callZephlyAPI('mcpCreateFeatureFlag', args);
+}
+
+async function updateFeatureFlag(args) {
+  return callZephlyAPI('mcpUpdateFeatureFlag', args);
+}
+
+async function deleteFeatureFlag({ flagId }) {
+  return callZephlyAPI('mcpDeleteFeatureFlag', { flagId });
+}
+
+async function transitionFeatureFlag({ flagId, status, reason }) {
+  return callZephlyAPI('mcpTransitionFeatureFlag', { flagId, status, reason });
+}
+
+async function linkFeatureFlagArtifact({ flagId, targetType, targetId }) {
+  return callZephlyAPI('mcpLinkFeatureFlag', { flagId, targetType, targetId });
+}
+
+async function unlinkFeatureFlagArtifact({ flagId, targetType, targetId }) {
+  return callZephlyAPI('mcpUnlinkFeatureFlag', { flagId, targetType, targetId });
+}

package/handlers/features.js

@@ -0,0 +1,137 @@
+/**
+ * Feature Handlers
+ * Handler functions for the Feature Compendium MCP tools (E-162).
+ *
+ * Features are org-level, durable product capabilities. These handlers are thin
+ * wrappers over /api/mcp/v1/features; dispatch and validation happen server-side
+ * in core/features.Service.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+
+/**
+ * Dispatch manage_feature actions.
+ */
+export async function manageFeature(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createFeature(params);
+  case 'update': return updateFeature(params);
+  case 'delete': return deleteFeature(params);
+  case 'link': return linkFeatureArtifact(params);
+  case 'unlink': return unlinkFeatureArtifact(params);
+  case 'promote_epic': return promoteEpic(params);
+  case 'generate_how_it_works': return generateHowItWorks(params);
+  case 'apply_how_it_works': return applyHowItWorks(params);
+  case 'apply_init': return applyInit(params);
+  default:
+    throw new Error(`Unknown action: ${action}. Expected create, update, delete, link, unlink, promote_epic, generate_how_it_works, apply_how_it_works, or apply_init.`);
+  }
+}
+
+/**
+ * Unified get/list/tree handler for features.
+ * - featureId, or organizationId + featureSlug → single lookup (optionally + links).
+ * - organizationId only → list (or tree when tree=true).
+ */
+export async function getFeature(args) {
+  const { tree, includeLinks, includeDetail, featureId, featureSlug, organizationId, ...filters } = args;
+  const isSingleLookup = featureId || (featureSlug && organizationId);
+
+  if (isSingleLookup) {
+    const params = featureId ? { featureId } : { organizationId, featureSlug };
+    const result = await callZephlyAPI('mcpGetFeature', params);
+    const lookupId = featureId || result?.feature?.id;
+    if (includeDetail && lookupId) {
+      // Aggregated view: linked artifacts grouped by type + rollup.
+      const detail = await callZephlyAPI('mcpGetFeatureDetail', { featureId: lookupId });
+      result.detail = detail?.detail ?? detail;
+    } else if (includeLinks && lookupId) {
+      const links = await callZephlyAPI('mcpListFeatureLinks', { featureId: lookupId });
+      result.links = links?.links ?? links;
+    }
+    return result;
+  }
+
+  // List / tree mode
+  const params = { organizationId };
+  // projectIds is the multi-project scope (E-242); the API takes it
+  // comma-separated and treats it as satisfying the mandatory project scope.
+  if (Array.isArray(filters.projectIds) && filters.projectIds.length > 0) {
+    params.projectIds = filters.projectIds.join(',');
+  } else if (filters.projectId) {
+    params.projectId = filters.projectId;
+  }
+  if (filters.status) params.status = filters.status;
+  if (tree) {
+    // A forest is a whole structure; the API ignores paging for it.
+    params.tree = 'true';
+    return callZephlyAPI('mcpListFeatures', params);
+  }
+  if (filters.search) params.search = filters.search;
+  if (filters.sortBy) params.sortBy = filters.sortBy;
+  if (filters.sortDir) params.sortDir = filters.sortDir;
+  if (filters.limit != null) params.limit = filters.limit;
+  if (filters.offset != null) params.offset = filters.offset;
+  return callZephlyAPI('mcpListFeatures', params);
+}
+
+/**
+ * Semantic search over an organization's features (capture-at-build gate, E-164).
+ * Returns existing features ranked by similarity so callers add to an existing
+ * capability instead of creating a duplicate.
+ */
+export async function searchFeatures(args) {
+  const { organizationId, query, limit } = args;
+  const params = { organizationId, query };
+  if (limit != null) params.limit = limit;
+  return callZephlyAPI('mcpSearchFeatures', params);
+}
+
+// --- Private helpers ---
+
+async function createFeature(args) {
+  return callZephlyAPI('mcpCreateFeature', args);
+}
+
+async function updateFeature(args) {
+  return callZephlyAPI('mcpUpdateFeature', args);
+}
+
+async function deleteFeature({ featureId }) {
+  return callZephlyAPI('mcpDeleteFeature', { featureId });
+}
+
+async function linkFeatureArtifact({ featureId, targetType, targetId }) {
+  return callZephlyAPI('mcpLinkFeatureArtifact', { featureId, targetType, targetId });
+}
+
+async function unlinkFeatureArtifact({ featureId, targetType, targetId }) {
+  return callZephlyAPI('mcpUnlinkFeatureArtifact', { featureId, targetType, targetId });
+}
+
+async function promoteEpic({ epicId }) {
+  return callZephlyAPI('mcpPromoteEpicToFeature', { epicId });
+}
+
+// Generate (and persist) the feature's grounded "how it works" living
+// description via the model (E-165). AI-quota gated server-side.
+async function generateHowItWorks({ featureId }) {
+  return callZephlyAPI('mcpGenerateHowItWorks', { featureId });
+}
+
+// Apply (persist) a LOCAL-agent-authored "how it works" for a feature (BYO-AI,
+// E-190). The agent writes { markdown, sources }; the server validates the cited
+// sources against the real grounded context before saving. No server model call.
+async function applyHowItWorks({ featureId, markdown, sources }) {
+  return callZephlyAPI('mcpApplyHowItWorks', { featureId, markdown, sources });
+}
+
+// Apply an approved init/backfill proposal tree (E-167): create features
+// (parents→children), backfill links, and persist any agent-authored "how it
+// works". The clustering/inference runs locally in the desktop with the user's
+// own AI; this only commits the human-approved result. Server-side ApplyInit
+// resolves tempId→featureId ordering and validates sources.
+async function applyInit({ organizationId, projectId, nodes }) {
+  return callZephlyAPI('mcpApplyFeatureInit', { organizationId, projectId, nodes });
+}

package/handlers/folders.js

@@ -0,0 +1,127 @@
+/**
+ * Folder Handlers
+ * Handler functions for document folder-related MCP tools
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+
+/**
+ * Dispatch manage_folder actions to the appropriate handler
+ */
+export async function manageFolder(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createFolder(params);
+  case 'update': return updateFolder(params);
+  case 'delete': return deleteFolder(params);
+  default: throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+/**
+ * Unified list handler for folders.
+ * mode='tree' returns hierarchical view, mode='flat' (default) returns flat list.
+ */
+export async function listFolders(args) {
+  const { mode, ...rest } = args;
+
+  if (mode === 'tree') {
+    return getFolderTree(rest);
+  }
+
+  return fetchFolderList(rest);
+}
+
+/**
+ * List an organization's reserved document areas (Goals, Features, ADRs,
+ * How it works), creating any that are missing. (E-195)
+ * Params: organizationId (required).
+ */
+export async function getOrgAreas(args) {
+  return callZephlyAPI('mcpGetOrgAreas', args);
+}
+
+// --- Private helpers ---
+
+async function fetchFolderList(args) {
+  return callZephlyAPI('mcpListFolders', args);
+}
+
+async function getFolderTree(args) {
+  return callZephlyAPI('mcpGetFolderTree', args);
+}
+
+/**
+ * Access is not a property of a folder write: neither folders.CreateFolderRequest
+ * nor UpdateFolderRequest carries an access field, so an `access` object was
+ * decoded away to nothing on both paths (#2168). The capability itself is real
+ * and now HAS an MCP surface of its own — the polymorphic manage_access tool
+ * (#2170) — so the honest response is to do the folder write and point at the
+ * tool that actually applies access, rather than dropping it silently or
+ * failing the whole call over it.
+ */
+const ACCESS_UNSUPPORTED =
+  'The `access` field was ignored: access is not set through manage_folder. ' +
+  'Use manage_access with entityType:"folder" (action "update_settings" or "add_entry") ' +
+  'to apply it. Note only root folders carry their own access — nested folders ' +
+  'inherit from their root folder.';
+
+async function createFolder(args) {
+  // Map parentFolderId (MCP schema) → parentId (Go API field name)
+  const { parentFolderId, access, ...rest } = args;
+  const mapped = { ...rest };
+  if (parentFolderId) {
+    mapped.parentId = parentFolderId;
+  }
+  const result = await callZephlyAPI('mcpCreateFolder', mapped);
+  if (access !== undefined) result.warning = ACCESS_UNSUPPORTED;
+  return result;
+}
+
+async function updateFolder(args) {
+  const { parentFolderId, access, ...rest } = args;
+
+  // Check if there are fields to update beyond projectId/folderId. `access` is
+  // deliberately NOT counted: it cannot be applied, so counting it would report
+  // a successful update that changed nothing.
+  const hasFieldUpdates = rest.name || rest.color || rest.icon;
+  let result;
+
+  if (hasFieldUpdates) {
+    result = await callZephlyAPI('mcpUpdateFolder', rest);
+  } else {
+    result = { success: true, folderId: args.folderId };
+  }
+
+  // Move folder if parentFolderId was specified
+  if (parentFolderId !== undefined) {
+    const newParentId = (parentFolderId === '' || parentFolderId === 'root') ? null : parentFolderId;
+    await callZephlyAPI('mcpMoveFolder', {
+      projectId: args.projectId,
+      folderId: args.folderId,
+      newParentId,
+    });
+    result.moved = true;
+    result.newParentId = newParentId;
+  }
+
+  if (!hasFieldUpdates && parentFolderId === undefined) {
+    // Name the access case explicitly. Reporting a bare "no updates provided"
+    // to a caller who did pass something reads as though the argument never
+    // arrived, sending them to debug their own call instead of the real answer.
+    throw new Error(
+      access !== undefined
+        ? `No applicable updates provided. ${ACCESS_UNSUPPORTED} ` +
+          'To update the folder itself, pass one of: name, color, icon, or parentFolderId.'
+        : 'No updates provided. Specify at least one of: name, color, icon, or parentFolderId.'
+    );
+  }
+
+  if (access !== undefined) result.warning = ACCESS_UNSUPPORTED;
+
+  return result;
+}
+
+async function deleteFolder(args) {
+  return callZephlyAPI('mcpDeleteFolder', args);
+}