@lumibase/mcp-server 0.22.0 → 0.24.0

package/dist/index.js

@@ -612,6 +612,14 @@ function registerAgentTools(server, client) {
     { description: "List recent runs of a flow.", inputSchema: { id: idPathSegmentSchema } },
     async ({ id }) => run(() => client.get(`/flows/${encodePathSegment(id)}/runs`))
   );
+  server.registerTool(
+    "get_flow_run",
+    {
+      description: "Get a single flow run by id (status, per-step results, error) for diagnosis.",
+      inputSchema: { id: idPathSegmentSchema, runId: idPathSegmentSchema }
+    },
+    async ({ id, runId }) => run(() => client.get(`/flows/${encodePathSegment(id)}/runs/${encodePathSegment(runId)}`))
+  );
 }
 
 // src/tools/api-keys.ts
@@ -997,6 +1005,22 @@ function registerContentConfigTools(server, client) {
     createSchema: presetSchema.shape,
     updateSchema: presetSchema.partial().shape
   });
+  server.registerTool(
+    "get_effective_preset",
+    {
+      description: "Resolve the effective default view for a collection (user > role-chain > global precedence).",
+      inputSchema: { collection: z9.string().min(1) }
+    },
+    async ({ collection }) => run(() => client.get(`/presets/effective?collection=${encodeURIComponent(collection)}`))
+  );
+  server.registerTool(
+    "list_preset_bookmarks",
+    {
+      description: "List the named preset bookmarks visible to the principal for a collection (with scope).",
+      inputSchema: { collection: z9.string().min(1) }
+    },
+    async ({ collection }) => run(() => client.get(`/presets/bookmarks?collection=${encodeURIComponent(collection)}`))
+  );
   registerCrud(server, client, {
     basePath: "/translations",
     resource: "translation",
@@ -1052,18 +1076,134 @@ function registerContentConfigTools(server, client) {
   );
 }
 
-// src/tools/extensions.ts
+// src/tools/deployments.ts
 import { z as z10 } from "zod";
+function registerDeploymentTools(server, client) {
+  server.registerTool(
+    "list_deployment_targets",
+    {
+      description: "List configured deployment targets (Vercel/Netlify connections) for the site.",
+      inputSchema: {}
+    },
+    async () => run(() => client.get("/deployments/targets"))
+  );
+  server.registerTool(
+    "list_deployments",
+    {
+      description: "List recent deployments, optionally filtered by target or status.",
+      inputSchema: {
+        targetId: z10.string().optional(),
+        status: z10.string().optional().describe("queued | building | ready | error | canceled."),
+        limit: z10.number().int().min(1).max(200).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/deployments${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "get_deployment",
+    {
+      description: "Get a single deployment\u2019s status and details by id.",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.get(`/deployments/${encodePathSegment(id)}`))
+  );
+  server.registerTool(
+    "get_deployment_logs",
+    {
+      description: "Fetch the build/deploy logs for a deployment (for diagnosing a failed build).",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.get(`/deployments/${encodePathSegment(id)}/logs`))
+  );
+}
+
+// src/tools/editorial.ts
+import { z as z11 } from "zod";
+function registerEditorialTools(server, client) {
+  server.registerTool(
+    "list_reviews",
+    {
+      description: "List the editorial review queue, optionally filtered by status or assignee.",
+      inputSchema: {
+        status: z11.enum(["pending", "approved", "rejected"]).optional(),
+        assignedTo: z11.string().max(128).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/editorial/reviews${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "submit_review",
+    {
+      description: "Submit an item for editorial review, optionally assigning a reviewer.",
+      inputSchema: {
+        collection: collectionNameSchema,
+        id: idPathSegmentSchema,
+        assignedTo: z11.string().min(1).max(128).nullable().optional()
+      }
+    },
+    async ({ collection, id, assignedTo }) => run(
+      () => client.post(
+        `/editorial/${encodePathSegment(collection)}/${encodePathSegment(id)}/submit-review`,
+        { assignedTo }
+      )
+    )
+  );
+  server.registerTool(
+    "approve_content",
+    {
+      description: "Approve an item in editorial review (a publish-gate decision). Optional reason is audited.",
+      inputSchema: {
+        collection: collectionNameSchema,
+        id: idPathSegmentSchema,
+        reason: z11.string().max(2e3).optional()
+      }
+    },
+    async ({ collection, id, reason }) => run(
+      () => client.post(
+        `/editorial/${encodePathSegment(collection)}/${encodePathSegment(id)}/approve`,
+        { reason }
+      )
+    )
+  );
+  server.registerTool(
+    "reject_content",
+    {
+      description: "Reject an item in editorial review. Optional reason is audited.",
+      inputSchema: {
+        collection: collectionNameSchema,
+        id: idPathSegmentSchema,
+        reason: z11.string().max(2e3).optional()
+      }
+    },
+    async ({ collection, id, reason }) => run(
+      () => client.post(
+        `/editorial/${encodePathSegment(collection)}/${encodePathSegment(id)}/reject`,
+        { reason }
+      )
+    )
+  );
+}
+
+// src/tools/extensions.ts
+import { z as z12 } from "zod";
 var EXTENSION_TYPES = ["interface", "display", "layout", "panel", "module", "hook", "endpoint"];
-var extensionSchema = z10.object({
-  key: z10.string().regex(/^[a-z0-9_:-]+$/).optional(),
-  name: z10.string().min(1),
-  version: z10.string().min(1),
-  type: z10.enum(EXTENSION_TYPES),
-  enabled: z10.boolean().optional(),
-  bundleUrl: z10.string().min(1).describe("https:, http:, or data:text/javascript bundle URL."),
-  manifest: z10.record(z10.string()).optional(),
-  capabilities: z10.array(z10.string()).optional()
+var extensionSchema = z12.object({
+  key: z12.string().regex(/^[a-z0-9_:-]+$/).optional(),
+  name: z12.string().min(1),
+  version: z12.string().min(1),
+  type: z12.enum(EXTENSION_TYPES),
+  enabled: z12.boolean().optional(),
+  bundleUrl: z12.string().min(1).describe("https:, http:, or data:text/javascript bundle URL."),
+  manifest: z12.record(z12.string()).optional(),
+  capabilities: z12.array(z12.string()).optional()
 });
 function registerExtensionTools(server, client) {
   server.registerTool(
@@ -1091,7 +1231,7 @@ function registerExtensionTools(server, client) {
     "uninstall_extension",
     {
       description: "Uninstall an extension from the site. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: z10.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: z12.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/extensions/${encodePathSegment(id)}`);
@@ -1103,12 +1243,12 @@ function registerExtensionTools(server, client) {
     {
       description: "Browse the published extension marketplace.",
       inputSchema: {
-        q: z10.string().optional(),
-        category: z10.string().optional(),
-        tags: z10.string().optional().describe("Comma-separated tags."),
-        sort: z10.string().optional(),
-        page: z10.number().int().min(1).optional(),
-        perPage: z10.number().int().min(1).optional()
+        q: z12.string().optional(),
+        category: z12.string().optional(),
+        tags: z12.string().optional().describe("Comma-separated tags."),
+        sort: z12.string().optional(),
+        page: z12.number().int().min(1).optional(),
+        perPage: z12.number().int().min(1).optional()
       }
     },
     async (args) => run(
@@ -1143,13 +1283,13 @@ function registerExtensionTools(server, client) {
     {
       description: "Publish an extension to the marketplace (signs + marks it published).",
       inputSchema: {
-        extensionId: z10.string().min(1),
-        marketplaceSlug: z10.string().min(1),
-        publisher: z10.record(z10.unknown()).optional(),
-        signature: z10.string().optional(),
-        signatureAlg: z10.string().optional(),
-        publisherKeyId: z10.string().optional(),
-        bundleSha256: z10.string().optional()
+        extensionId: z12.string().min(1),
+        marketplaceSlug: z12.string().min(1),
+        publisher: z12.record(z12.unknown()).optional(),
+        signature: z12.string().optional(),
+        signatureAlg: z12.string().optional(),
+        publisherKeyId: z12.string().optional(),
+        bundleSha256: z12.string().optional()
       }
     },
     async (input) => run(() => client.post("/marketplace/publish", input))
@@ -1157,39 +1297,39 @@ function registerExtensionTools(server, client) {
 }
 
 // src/tools/fields.ts
-import { z as z11 } from "zod";
-var fieldInputSchema2 = z11.object({
-  type: z11.string().min(1).describe(
+import { z as z13 } from "zod";
+var fieldInputSchema2 = z13.object({
+  type: z13.string().min(1).describe(
     "Storage type: string, text, integer, bigInteger, float, decimal, boolean, date, dateTime, time, json, uuid, csv, hash, alias"
   ),
-  interface: z11.string().min(1).describe(
+  interface: z13.string().min(1).describe(
     "UI widget: input, textarea, select, toggle, datetime, file, image, repeater, relation-m2o, relation-o2m, relation-m2m, code, markdown, wysiwyg, \u2026"
   ),
-  display: z11.string().optional(),
-  label: z11.string().optional(),
-  note: z11.string().optional(),
-  defaultValue: z11.unknown().optional(),
-  nullable: z11.boolean().optional().default(true),
-  unique: z11.boolean().optional().default(false),
-  indexed: z11.boolean().optional().default(false),
-  searchable: z11.boolean().optional().default(false),
-  length: z11.number().int().positive().optional(),
-  precision: z11.number().int().positive().optional(),
-  scale: z11.number().int().min(0).optional(),
-  special: z11.array(z11.string()).optional(),
-  options: z11.record(z11.unknown()).optional(),
-  displayOptions: z11.record(z11.unknown()).optional(),
-  conditions: z11.array(z11.unknown()).optional(),
-  required: z11.boolean().optional().default(false),
-  readonly: z11.boolean().optional().default(false),
-  hidden: z11.boolean().optional().default(false),
-  encrypted: z11.boolean().optional().default(false),
-  versioned: z11.boolean().optional().default(false),
-  width: z11.enum(["half", "full", "fill"]).optional().default("full"),
-  group: z11.string().optional(),
-  sortOrder: z11.number().int().optional(),
+  display: z13.string().optional(),
+  label: z13.string().optional(),
+  note: z13.string().optional(),
+  defaultValue: z13.unknown().optional(),
+  nullable: z13.boolean().optional().default(true),
+  unique: z13.boolean().optional().default(false),
+  indexed: z13.boolean().optional().default(false),
+  searchable: z13.boolean().optional().default(false),
+  length: z13.number().int().positive().optional(),
+  precision: z13.number().int().positive().optional(),
+  scale: z13.number().int().min(0).optional(),
+  special: z13.array(z13.string()).optional(),
+  options: z13.record(z13.unknown()).optional(),
+  displayOptions: z13.record(z13.unknown()).optional(),
+  conditions: z13.array(z13.unknown()).optional(),
+  required: z13.boolean().optional().default(false),
+  readonly: z13.boolean().optional().default(false),
+  hidden: z13.boolean().optional().default(false),
+  encrypted: z13.boolean().optional().default(false),
+  versioned: z13.boolean().optional().default(false),
+  width: z13.enum(["half", "full", "fill"]).optional().default("full"),
+  group: z13.string().optional(),
+  sortOrder: z13.number().int().optional(),
   renameFrom: fieldNameSchema.optional().describe("Previous field name if this is a rename operation"),
-  confirmRiskyChange: z11.boolean().optional().describe("Set true to confirm type-change or destructive migration")
+  confirmRiskyChange: z13.boolean().optional().describe("Set true to confirm type-change or destructive migration")
 });
 function formatError3(err) {
   if (err instanceof LumiBaseApiError) {
@@ -1244,8 +1384,8 @@ function registerFieldTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         field_name: fieldNameSchema,
-        confirm: z11.literal(true).describe("Must be true to confirm destructive operation"),
-        force: z11.boolean().optional().describe("Force deletion even if risky (foreign keys, etc.)")
+        confirm: z13.literal(true).describe("Must be true to confirm destructive operation"),
+        force: z13.boolean().optional().describe("Force deletion even if risky (foreign keys, etc.)")
       }
     },
     async ({ collection, field_name, force }) => {
@@ -1264,8 +1404,91 @@ function registerFieldTools(server, client) {
   );
 }
 
+// src/tools/insights.ts
+import { z as z14 } from "zod";
+var AGGREGATES = ["count", "sum", "avg", "min", "max"];
+var dateRangeSchema = z14.object({
+  field: z14.string().min(1),
+  gte: z14.string().optional(),
+  lte: z14.string().optional(),
+  preset: z14.string().optional()
+}).describe("Restrict the query to a date window on the given field.");
+var panelQueryShape = {
+  collection: z14.string().min(1),
+  aggregate: z14.enum(AGGREGATES).describe("Aggregate function. `field` is required for everything except `count`."),
+  field: z14.string().min(1).optional().describe("Field to aggregate (required unless aggregate=count)."),
+  groupBy: z14.string().min(1).optional().describe("Field to group rows by (produces a series)."),
+  filter: z14.record(z14.unknown()).optional().describe('Directus-style condition rule, e.g. { status: { _eq: "published" } }.'),
+  dateRange: dateRangeSchema.optional(),
+  limit: z14.number().int().min(1).max(1e3).optional().describe("Max grouped rows to return (default 50).")
+};
+function registerInsightsTools(server, client) {
+  server.registerTool(
+    "list_dashboards",
+    {
+      description: "List insight dashboards for the current site.",
+      inputSchema: {}
+    },
+    async () => run(() => client.get("/dashboards"))
+  );
+  server.registerTool(
+    "get_dashboard",
+    {
+      description: "Get a single dashboard by id.",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.get(`/dashboards/${encodePathSegment(id)}`))
+  );
+  server.registerTool(
+    "list_dashboard_panels",
+    {
+      description: "List the panels of a dashboard (their definitions, not the computed data).",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.get(`/dashboards/${encodePathSegment(id)}/panels`))
+  );
+  server.registerTool(
+    "run_panel",
+    {
+      description: "Run a saved panel and return its computed result. Optionally override the panel\u2019s filter or date range for this run only (does not modify the panel).",
+      inputSchema: {
+        dashboardId: idPathSegmentSchema,
+        panelId: idPathSegmentSchema,
+        filter: z14.record(z14.unknown()).optional().describe("Override the panel filter for this run (Directus-style condition rule)."),
+        dateRange: dateRangeSchema.optional().describe("Override the panel date range for this run.")
+      }
+    },
+    async ({ dashboardId, panelId, filter, dateRange }) => {
+      const override = {};
+      if (filter !== void 0) override["filter"] = filter;
+      if (dateRange !== void 0) override["dateRange"] = dateRange;
+      return run(
+        () => client.post(
+          `/dashboards/${encodePathSegment(dashboardId)}/panels/${encodePathSegment(panelId)}/data`,
+          override
+        )
+      );
+    }
+  );
+  server.registerTool(
+    "query_insights",
+    {
+      description: "Ad-hoc aggregate query over a collection \u2014 no saved panel required. Answers operational questions (counts, sums, averages, breakdowns) directly. Read-only.",
+      inputSchema: {
+        dashboardId: idPathSegmentSchema.describe(
+          "Any dashboard id you can access; the query runs ad-hoc and does not read that dashboard."
+        ),
+        ...panelQueryShape
+      }
+    },
+    async ({ dashboardId, ...query }) => run(
+      () => client.post(`/dashboards/${encodePathSegment(dashboardId)}/panels/preview`, query)
+    )
+  );
+}
+
 // src/tools/items.ts
-import { z as z12 } from "zod";
+import { z as z15 } from "zod";
 function formatError4(err) {
   if (err instanceof LumiBaseApiError) {
     return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
@@ -1287,12 +1510,12 @@ function registerItemTools(server, client) {
       description: "List items from a collection with optional filtering, sorting, and pagination.",
       inputSchema: {
         collection: collectionNameSchema,
-        limit: z12.number().int().min(1).max(200).optional().default(25),
-        offset: z12.number().int().min(0).optional().default(0),
-        status: z12.enum(["draft", "published", "archived"]).optional(),
-        sort: z12.string().optional().describe('Comma-separated field names; prefix with - for descending (e.g. "-created_at")'),
-        fields: z12.string().optional().describe('Comma-separated field names to return (e.g. "id,title,status")'),
-        search: z12.string().optional().describe("Full-text search across searchable fields")
+        limit: z15.number().int().min(1).max(200).optional().default(25),
+        offset: z15.number().int().min(0).optional().default(0),
+        status: z15.enum(["draft", "published", "archived"]).optional(),
+        sort: z15.string().optional().describe('Comma-separated field names; prefix with - for descending (e.g. "-created_at")'),
+        fields: z15.string().optional().describe('Comma-separated field names to return (e.g. "id,title,status")'),
+        search: z15.string().optional().describe("Full-text search across searchable fields")
       }
     },
     async ({ collection, ...params }) => {
@@ -1312,7 +1535,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        fields: z12.string().optional().describe("Comma-separated field names to return")
+        fields: z15.string().optional().describe("Comma-separated field names to return")
       }
     },
     async ({ collection, id, fields }) => {
@@ -1333,8 +1556,8 @@ function registerItemTools(server, client) {
       description: "Create a new item in a collection.",
       inputSchema: {
         collection: collectionNameSchema,
-        data: z12.record(z12.unknown()).describe("Field values for the new item"),
-        status: z12.enum(["draft", "published"]).optional().default("draft")
+        data: z15.record(z15.unknown()).describe("Field values for the new item"),
+        status: z15.enum(["draft", "published"]).optional().default("draft")
       }
     },
     async ({ collection, data: itemData, status }) => {
@@ -1356,7 +1579,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        data: z12.record(z12.unknown()).describe("Fields to update")
+        data: z15.record(z15.unknown()).describe("Fields to update")
       }
     },
     async ({ collection, id, data: itemData }) => {
@@ -1378,7 +1601,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        confirm: z12.literal(true).describe("Must be true to confirm deletion")
+        confirm: z15.literal(true).describe("Must be true to confirm deletion")
       }
     },
     async ({ collection, id }) => {
@@ -1392,16 +1615,137 @@ function registerItemTools(server, client) {
   );
 }
 
+// src/tools/releases.ts
+import { z as z16 } from "zod";
+var releaseItemSchema = z16.object({
+  collection: z16.string().min(1),
+  itemId: z16.string().min(1),
+  targetStatus: z16.enum(["draft", "published", "archived"]).optional(),
+  revisionId: z16.string().nullable().optional()
+});
+function registerReleaseTools(server, client) {
+  server.registerTool(
+    "list_releases",
+    {
+      description: "List content releases for the site, optionally filtered by status.",
+      inputSchema: {
+        status: z16.string().optional(),
+        page: z16.number().int().min(1).optional(),
+        limit: z16.number().int().min(1).max(200).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/releases${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "get_release",
+    {
+      description: "Get a single content release by id (with its staged items).",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.get(`/releases/${encodePathSegment(id)}`))
+  );
+  server.registerTool(
+    "create_release",
+    {
+      description: "Create a content release. Set publishAt for a scheduled release; omit for a manual one.",
+      inputSchema: {
+        name: z16.string().min(1),
+        description: z16.string().nullable().optional(),
+        atomicityMode: z16.enum(["all_or_nothing", "best_effort"]).optional(),
+        publishAt: z16.string().nullable().optional().describe("ISO datetime to auto-publish, or null.")
+      }
+    },
+    async (input) => run(() => client.post("/releases", input))
+  );
+  server.registerTool(
+    "update_release",
+    {
+      description: "Update a release and/or stage/unstage items (partial PATCH).",
+      inputSchema: {
+        id: idPathSegmentSchema,
+        name: z16.string().min(1).optional(),
+        description: z16.string().nullable().optional(),
+        atomicityMode: z16.enum(["all_or_nothing", "best_effort"]).optional(),
+        publishAt: z16.string().nullable().optional(),
+        addItems: z16.array(releaseItemSchema).optional().describe("Items to stage into the release."),
+        removeItems: z16.array(z16.object({ collection: z16.string(), itemId: z16.string() })).optional().describe("Items to unstage.")
+      }
+    },
+    async ({ id, ...patch }) => run(() => client.patch(`/releases/${encodePathSegment(id)}`, patch))
+  );
+  server.registerTool(
+    "publish_release",
+    {
+      description: "Publish a release now (applies every staged item\u2019s target status per the atomicity mode).",
+      inputSchema: { id: idPathSegmentSchema }
+    },
+    async ({ id }) => run(() => client.post(`/releases/${encodePathSegment(id)}/publish`, {}))
+  );
+  server.registerTool(
+    "delete_release",
+    {
+      description: "Delete a content release. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        id: idPathSegmentSchema,
+        confirm: z16.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/releases/${encodePathSegment(id)}`);
+      return okText(`Release "${id}" deleted.`);
+    })
+  );
+}
+
+// src/tools/shares.ts
+import { z as z17 } from "zod";
+function registerShareTools(server, client) {
+  server.registerTool(
+    "create_share",
+    {
+      description: "Create a scoped public share link for a single item, viewed through a given role.",
+      inputSchema: {
+        collection: z17.string().min(1),
+        itemId: z17.string().min(1),
+        roleId: z17.string().min(1).describe("Role whose permissions the link is viewed through."),
+        password: z17.string().min(1).optional(),
+        validFrom: z17.string().datetime().nullable().optional(),
+        validUntil: z17.string().datetime().nullable().optional(),
+        maxUses: z17.number().int().min(1).nullable().optional()
+      }
+    },
+    async (input) => run(() => client.post("/shares", input))
+  );
+  server.registerTool(
+    "revoke_share",
+    {
+      description: "Revoke a share link by id. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        id: idPathSegmentSchema,
+        confirm: z17.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id }) => run(async () => {
+      await client.post(`/shares/${encodePathSegment(id)}/revoke`, {});
+      return okText(`Share link "${id}" revoked.`);
+    })
+  );
+}
+
 // src/tools/ops.ts
-import { z as z13 } from "zod";
+import { z as z18 } from "zod";
 function registerOpsTools(server, client) {
   server.registerTool(
     "list_activity",
     {
       description: "List the site activity / audit trail (most recent first).",
       inputSchema: {
-        limit: z13.number().int().min(1).max(500).optional(),
-        offset: z13.number().int().min(0).optional()
+        limit: z18.number().int().min(1).max(500).optional(),
+        offset: z18.number().int().min(0).optional()
       }
     },
     async (args) => run(
@@ -1410,6 +1754,14 @@ function registerOpsTools(server, client) {
       )
     )
   );
+  server.registerTool(
+    "get_site",
+    {
+      description: "Get the current site\u2019s configuration record (name, domain, settings).",
+      inputSchema: {}
+    },
+    async () => run(() => client.get("/site"))
+  );
   server.registerTool(
     "get_health",
     { description: "Check the CMS health endpoint.", inputSchema: {} },
@@ -1423,7 +1775,7 @@ function registerOpsTools(server, client) {
 }
 
 // src/tools/permissions.ts
-import { z as z14 } from "zod";
+import { z as z19 } from "zod";
 function registerPermissionTools(server, client) {
   server.registerTool(
     "get_my_permissions",
@@ -1438,9 +1790,9 @@ function registerPermissionTools(server, client) {
     {
       description: "Evaluate whether the current principal may perform an action on a collection (optionally against a specific item), returning { allowed, reason, fields }.",
       inputSchema: {
-        collection: z14.string().min(1),
-        action: z14.enum(["create", "read", "update", "delete", "share"]),
-        item: z14.record(z14.unknown()).optional().describe("Item payload to evaluate row-level rules against.")
+        collection: z19.string().min(1),
+        action: z19.enum(["create", "read", "update", "delete", "share"]),
+        item: z19.record(z19.unknown()).optional().describe("Item payload to evaluate row-level rules against.")
       }
     },
     async (input) => run(() => client.post("/permissions/check", input))
@@ -1448,21 +1800,21 @@ function registerPermissionTools(server, client) {
 }
 
 // src/tools/relations.ts
-import { z as z15 } from "zod";
+import { z as z20 } from "zod";
 var relationInputSchema = {
-  manyCollection: z15.string().min(1).describe('Collection that holds the foreign key (the "many" side).'),
-  manyField: z15.string().min(1).describe("Field on manyCollection that stores the relation."),
-  oneCollection: z15.string().min(1).describe('Related collection (the "one" side).'),
-  oneField: z15.string().nullable().optional(),
-  junctionCollection: z15.string().nullable().optional().describe("Junction table for m2m relations."),
-  type: z15.enum(["m2o", "o2m", "m2m", "m2a"]).optional(),
-  aliasField: z15.string().nullable().optional(),
-  relatedDisplayTemplate: z15.string().nullable().optional(),
-  junctionManyField: z15.string().nullable().optional(),
-  junctionOneField: z15.string().nullable().optional(),
-  sortField: z15.string().nullable().optional(),
-  onDelete: z15.enum(["restrict", "cascade", "set null", "no action"]).optional(),
-  meta: z15.record(z15.unknown()).optional()
+  manyCollection: z20.string().min(1).describe('Collection that holds the foreign key (the "many" side).'),
+  manyField: z20.string().min(1).describe("Field on manyCollection that stores the relation."),
+  oneCollection: z20.string().min(1).describe('Related collection (the "one" side).'),
+  oneField: z20.string().nullable().optional(),
+  junctionCollection: z20.string().nullable().optional().describe("Junction table for m2m relations."),
+  type: z20.enum(["m2o", "o2m", "m2m", "m2a"]).optional(),
+  aliasField: z20.string().nullable().optional(),
+  relatedDisplayTemplate: z20.string().nullable().optional(),
+  junctionManyField: z20.string().nullable().optional(),
+  junctionOneField: z20.string().nullable().optional(),
+  sortField: z20.string().nullable().optional(),
+  onDelete: z20.enum(["restrict", "cascade", "set null", "no action"]).optional(),
+  meta: z20.record(z20.unknown()).optional()
 };
 function registerRelationTools(server, client) {
   server.registerTool(
@@ -1484,7 +1836,7 @@ function registerRelationTools(server, client) {
       description: "Delete a relation by id. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
       inputSchema: {
         id: idPathSegmentSchema,
-        confirm: z15.literal(true).describe(confirmDescription)
+        confirm: z20.literal(true).describe(confirmDescription)
       }
     },
     async ({ id }) => run(async () => {
@@ -1495,19 +1847,19 @@ function registerRelationTools(server, client) {
 }
 
 // src/tools/search-media.ts
-import { z as z16 } from "zod";
+import { z as z21 } from "zod";
 function registerSearchMediaTools(server, client) {
   server.registerTool(
     "search",
     {
       description: "Full-text search within a collection. Returns ranked hits from the search backend. The `collection` parameter is required.",
       inputSchema: {
-        q: z16.string().min(1).describe("Query string."),
-        collection: z16.string().min(1).describe("Collection to search."),
-        filter: z16.string().optional().describe("Backend filter expression."),
-        sort: z16.string().optional().describe("Comma-separated sort fields."),
-        limit: z16.number().int().min(1).max(200).optional(),
-        offset: z16.number().int().min(0).optional()
+        q: z21.string().min(1).describe("Query string."),
+        collection: z21.string().min(1).describe("Collection to search."),
+        filter: z21.string().optional().describe("Backend filter expression."),
+        sort: z21.string().optional().describe("Comma-separated sort fields."),
+        limit: z21.number().int().min(1).max(200).optional(),
+        offset: z21.number().int().min(0).optional()
       }
     },
     async (args) => run(
@@ -1520,7 +1872,7 @@ function registerSearchMediaTools(server, client) {
     "list_media",
     {
       description: "List media asset keys, optionally filtered by key prefix.",
-      inputSchema: { prefix: z16.string().optional() }
+      inputSchema: { prefix: z21.string().optional() }
     },
     async ({ prefix }) => run(() => client.get(`/media${prefix ? `?prefix=${encodeURIComponent(prefix)}` : ""}`))
   );
@@ -1530,7 +1882,7 @@ function registerSearchMediaTools(server, client) {
       description: "Delete a media asset by key. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
       inputSchema: {
         key: mediaKeySchema.describe("Full storage key of the asset."),
-        confirm: z16.literal(true).describe(confirmDescription)
+        confirm: z21.literal(true).describe(confirmDescription)
       }
     },
     async ({ key }) => run(async () => {
@@ -1538,18 +1890,26 @@ function registerSearchMediaTools(server, client) {
       return okText(`Media asset "${key}" deleted.`);
     })
   );
+  server.registerTool(
+    "list_transform_presets",
+    {
+      description: "List named image-transform presets available for media delivery (key + DSL).",
+      inputSchema: {}
+    },
+    async () => run(() => client.get("/transform-presets"))
+  );
 }
 
 // src/tools/translation-memory.ts
-import { z as z17 } from "zod";
+import { z as z22 } from "zod";
 function registerTranslationMemoryTools(server, client) {
   server.registerTool(
     "list_tm",
     {
       description: "List translation-memory entries, optionally filtered by source/target language.",
       inputSchema: {
-        source: z17.string().optional().describe("Source language code."),
-        target: z17.string().optional().describe("Target language code.")
+        source: z22.string().optional().describe("Source language code."),
+        target: z22.string().optional().describe("Target language code.")
       }
     },
     async (args) => run(
@@ -1561,14 +1921,14 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Add or update a translation-memory entry.",
       inputSchema: {
-        sourceLang: z17.string().min(2),
-        targetLang: z17.string().min(2),
-        sourceText: z17.string().min(1),
-        targetText: z17.string().min(1),
-        context: z17.string().optional(),
-        quality: z17.number().min(0).max(100).optional(),
-        source: z17.enum(["human", "mt", "imported"]).optional(),
-        provider: z17.string().optional()
+        sourceLang: z22.string().min(2),
+        targetLang: z22.string().min(2),
+        sourceText: z22.string().min(1),
+        targetText: z22.string().min(1),
+        context: z22.string().optional(),
+        quality: z22.number().min(0).max(100).optional(),
+        source: z22.enum(["human", "mt", "imported"]).optional(),
+        provider: z22.string().optional()
       }
     },
     async (input) => run(() => client.post("/tm", input))
@@ -1578,10 +1938,10 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Fuzzy-match a query string against translation memory for a language pair.",
       inputSchema: {
-        query: z17.string().min(1),
-        sourceLang: z17.string().min(2),
-        targetLang: z17.string().min(2),
-        threshold: z17.number().min(0).max(100).optional().describe("Minimum match score (default 75).")
+        query: z22.string().min(1),
+        sourceLang: z22.string().min(2),
+        targetLang: z22.string().min(2),
+        threshold: z22.number().min(0).max(100).optional().describe("Minimum match score (default 75).")
       }
     },
     async (input) => run(() => client.post("/tm/lookup", input))
@@ -1591,18 +1951,46 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Run the full translation pipeline (TM + glossary + MT provider) for a text.",
       inputSchema: {
-        text: z17.string().min(1),
-        from: z17.string().min(2),
-        to: z17.string().min(2),
-        provider: z17.string().optional()
+        text: z22.string().min(1),
+        from: z22.string().min(2),
+        to: z22.string().min(2),
+        provider: z22.string().optional()
       }
     },
     async (input) => run(() => client.post("/tm/translate", input))
   );
+  server.registerTool(
+    "update_tm",
+    {
+      description: "Edit an existing translation-memory entry (partial PATCH).",
+      inputSchema: {
+        id: idPathSegmentSchema,
+        targetText: z22.string().min(1).optional(),
+        quality: z22.number().min(0).max(100).optional(),
+        context: z22.string().nullable().optional(),
+        source: z22.enum(["human", "mt", "imported"]).optional()
+      }
+    },
+    async ({ id, ...patch }) => run(() => client.patch(`/tm/${encodePathSegment(id)}`, patch))
+  );
+  server.registerTool(
+    "delete_tm",
+    {
+      description: "Delete a translation-memory entry. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        id: idPathSegmentSchema,
+        confirm: z22.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/tm/${encodePathSegment(id)}`);
+      return okText(`Translation-memory entry "${id}" deleted.`);
+    })
+  );
 }
 
 // src/tools/users-teams.ts
-import { z as z18 } from "zod";
+import { z as z23 } from "zod";
 function registerUsersTeamsTools(server, client) {
   server.registerTool(
     "list_users",
@@ -1619,8 +2007,8 @@ function registerUsersTeamsTools(server, client) {
     {
       description: "Invite a user to the site by email, optionally assigning a role. Sends an invite email.",
       inputSchema: {
-        email: z18.string().email(),
-        roleId: z18.string().optional()
+        email: z23.string().email(),
+        roleId: z23.string().optional()
       }
     },
     async (input) => run(() => client.post("/users/invite", input))
@@ -1631,8 +2019,8 @@ function registerUsersTeamsTools(server, client) {
       description: "Update a user's site membership (role and/or status).",
       inputSchema: {
         id: idPathSegmentSchema,
-        roleId: z18.string().nullable().optional(),
-        status: z18.string().optional().describe("e.g. active, suspended.")
+        roleId: z23.string().nullable().optional(),
+        status: z23.string().optional().describe("e.g. active, suspended.")
       }
     },
     async ({ id, ...patch }) => run(() => client.patch(`/users/${encodePathSegment(id)}`, patch))
@@ -1641,7 +2029,7 @@ function registerUsersTeamsTools(server, client) {
     "remove_user",
     {
       description: "Remove a user from the site. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: z18.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: z23.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/users/${encodePathSegment(id)}`);
@@ -1662,7 +2050,7 @@ function registerUsersTeamsTools(server, client) {
     "create_team",
     {
       description: "Create a team.",
-      inputSchema: { name: z18.string().min(1).max(128), description: z18.string().nullable().optional() }
+      inputSchema: { name: z23.string().min(1).max(128), description: z23.string().nullable().optional() }
     },
     async (input) => run(() => client.post("/teams", input))
   );
@@ -1672,8 +2060,8 @@ function registerUsersTeamsTools(server, client) {
       description: "Update a team (partial PATCH).",
       inputSchema: {
         id: idPathSegmentSchema,
-        name: z18.string().min(1).max(128).optional(),
-        description: z18.string().nullable().optional()
+        name: z23.string().min(1).max(128).optional(),
+        description: z23.string().nullable().optional()
       }
     },
     async ({ id, ...patch }) => run(() => client.patch(`/teams/${encodePathSegment(id)}`, patch))
@@ -1682,7 +2070,7 @@ function registerUsersTeamsTools(server, client) {
     "delete_team",
     {
       description: "Delete a team. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: z18.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: z23.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/teams/${encodePathSegment(id)}`);
@@ -1709,7 +2097,7 @@ function registerUsersTeamsTools(server, client) {
       inputSchema: {
         id: idPathSegmentSchema.describe("Team id."),
         userId: idPathSegmentSchema,
-        confirm: z18.literal(true).describe(confirmDescription)
+        confirm: z23.literal(true).describe(confirmDescription)
       }
     },
     async ({ id, userId }) => run(async () => {
@@ -1720,15 +2108,15 @@ function registerUsersTeamsTools(server, client) {
 }
 
 // src/tools/webhooks.ts
-import { z as z19 } from "zod";
-var webhookSchema = z19.object({
-  name: z19.string().min(1).max(255),
-  url: z19.string().url(),
-  actions: z19.array(z19.string()).optional().describe("Item events that trigger the webhook (e.g. create, update, delete)."),
-  collections: z19.array(z19.string()).optional().describe("Collections to filter on (empty = all)."),
-  headers: z19.record(z19.string()).optional(),
-  status: z19.enum(["active", "inactive"]).optional(),
-  secret: z19.string().nullable().optional()
+import { z as z24 } from "zod";
+var webhookSchema = z24.object({
+  name: z24.string().min(1).max(255),
+  url: z24.string().url(),
+  actions: z24.array(z24.string()).optional().describe("Item events that trigger the webhook (e.g. create, update, delete)."),
+  collections: z24.array(z24.string()).optional().describe("Collections to filter on (empty = all)."),
+  headers: z24.record(z24.string()).optional(),
+  status: z24.enum(["active", "inactive"]).optional(),
+  secret: z24.string().nullable().optional()
 });
 function registerWebhookTools(server, client) {
   registerCrud(server, client, {
@@ -1751,6 +2139,10 @@ function registerAllTools(server, client) {
   registerContentConfigTools(server, client);
   registerSearchMediaTools(server, client);
   registerTranslationMemoryTools(server, client);
+  registerInsightsTools(server, client);
+  registerEditorialTools(server, client);
+  registerReleaseTools(server, client);
+  registerShareTools(server, client);
   registerPermissionTools(server, client);
   registerAccessTools(server, client);
   registerApiKeyTools(server, client);
@@ -1761,6 +2153,7 @@ function registerAllTools(server, client) {
   registerOpsTools(server, client);
   registerAdminTools(server, client);
   registerExtensionTools(server, client);
+  registerDeploymentTools(server, client);
 }
 
 // src/index.ts