@lumibase/mcp-server 0.23.0 → 0.24.1

package/dist/index.cjs

@@ -613,6 +613,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
@@ -998,6 +1006,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: import_zod9.z.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: import_zod9.z.string().min(1) }
+    },
+    async ({ collection }) => run(() => client.get(`/presets/bookmarks?collection=${encodeURIComponent(collection)}`))
+  );
   registerCrud(server, client, {
     basePath: "/translations",
     resource: "translation",
@@ -1053,18 +1077,134 @@ function registerContentConfigTools(server, client) {
   );
 }
 
-// src/tools/extensions.ts
+// src/tools/deployments.ts
 var import_zod10 = require("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: import_zod10.z.string().optional(),
+        status: import_zod10.z.string().optional().describe("queued | building | ready | error | canceled."),
+        limit: import_zod10.z.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
+var import_zod11 = require("zod");
+function registerEditorialTools(server, client) {
+  server.registerTool(
+    "list_reviews",
+    {
+      description: "List the editorial review queue, optionally filtered by status or assignee.",
+      inputSchema: {
+        status: import_zod11.z.enum(["pending", "approved", "rejected"]).optional(),
+        assignedTo: import_zod11.z.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: import_zod11.z.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: import_zod11.z.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: import_zod11.z.string().max(2e3).optional()
+      }
+    },
+    async ({ collection, id, reason }) => run(
+      () => client.post(
+        `/editorial/${encodePathSegment(collection)}/${encodePathSegment(id)}/reject`,
+        { reason }
+      )
+    )
+  );
+}
+
+// src/tools/extensions.ts
+var import_zod12 = require("zod");
 var EXTENSION_TYPES = ["interface", "display", "layout", "panel", "module", "hook", "endpoint"];
-var extensionSchema = import_zod10.z.object({
-  key: import_zod10.z.string().regex(/^[a-z0-9_:-]+$/).optional(),
-  name: import_zod10.z.string().min(1),
-  version: import_zod10.z.string().min(1),
-  type: import_zod10.z.enum(EXTENSION_TYPES),
-  enabled: import_zod10.z.boolean().optional(),
-  bundleUrl: import_zod10.z.string().min(1).describe("https:, http:, or data:text/javascript bundle URL."),
-  manifest: import_zod10.z.record(import_zod10.z.string()).optional(),
-  capabilities: import_zod10.z.array(import_zod10.z.string()).optional()
+var extensionSchema = import_zod12.z.object({
+  key: import_zod12.z.string().regex(/^[a-z0-9_:-]+$/).optional(),
+  name: import_zod12.z.string().min(1),
+  version: import_zod12.z.string().min(1),
+  type: import_zod12.z.enum(EXTENSION_TYPES),
+  enabled: import_zod12.z.boolean().optional(),
+  bundleUrl: import_zod12.z.string().min(1).describe("https:, http:, or data:text/javascript bundle URL."),
+  manifest: import_zod12.z.record(import_zod12.z.string()).optional(),
+  capabilities: import_zod12.z.array(import_zod12.z.string()).optional()
 });
 function registerExtensionTools(server, client) {
   server.registerTool(
@@ -1092,7 +1232,7 @@ function registerExtensionTools(server, client) {
     "uninstall_extension",
     {
       description: "Uninstall an extension from the site. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: import_zod10.z.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: import_zod12.z.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/extensions/${encodePathSegment(id)}`);
@@ -1104,12 +1244,12 @@ function registerExtensionTools(server, client) {
     {
       description: "Browse the published extension marketplace.",
       inputSchema: {
-        q: import_zod10.z.string().optional(),
-        category: import_zod10.z.string().optional(),
-        tags: import_zod10.z.string().optional().describe("Comma-separated tags."),
-        sort: import_zod10.z.string().optional(),
-        page: import_zod10.z.number().int().min(1).optional(),
-        perPage: import_zod10.z.number().int().min(1).optional()
+        q: import_zod12.z.string().optional(),
+        category: import_zod12.z.string().optional(),
+        tags: import_zod12.z.string().optional().describe("Comma-separated tags."),
+        sort: import_zod12.z.string().optional(),
+        page: import_zod12.z.number().int().min(1).optional(),
+        perPage: import_zod12.z.number().int().min(1).optional()
       }
     },
     async (args) => run(
@@ -1144,13 +1284,13 @@ function registerExtensionTools(server, client) {
     {
       description: "Publish an extension to the marketplace (signs + marks it published).",
       inputSchema: {
-        extensionId: import_zod10.z.string().min(1),
-        marketplaceSlug: import_zod10.z.string().min(1),
-        publisher: import_zod10.z.record(import_zod10.z.unknown()).optional(),
-        signature: import_zod10.z.string().optional(),
-        signatureAlg: import_zod10.z.string().optional(),
-        publisherKeyId: import_zod10.z.string().optional(),
-        bundleSha256: import_zod10.z.string().optional()
+        extensionId: import_zod12.z.string().min(1),
+        marketplaceSlug: import_zod12.z.string().min(1),
+        publisher: import_zod12.z.record(import_zod12.z.unknown()).optional(),
+        signature: import_zod12.z.string().optional(),
+        signatureAlg: import_zod12.z.string().optional(),
+        publisherKeyId: import_zod12.z.string().optional(),
+        bundleSha256: import_zod12.z.string().optional()
       }
     },
     async (input) => run(() => client.post("/marketplace/publish", input))
@@ -1158,39 +1298,39 @@ function registerExtensionTools(server, client) {
 }
 
 // src/tools/fields.ts
-var import_zod11 = require("zod");
-var fieldInputSchema2 = import_zod11.z.object({
-  type: import_zod11.z.string().min(1).describe(
+var import_zod13 = require("zod");
+var fieldInputSchema2 = import_zod13.z.object({
+  type: import_zod13.z.string().min(1).describe(
     "Storage type: string, text, integer, bigInteger, float, decimal, boolean, date, dateTime, time, json, uuid, csv, hash, alias"
   ),
-  interface: import_zod11.z.string().min(1).describe(
+  interface: import_zod13.z.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: import_zod11.z.string().optional(),
-  label: import_zod11.z.string().optional(),
-  note: import_zod11.z.string().optional(),
-  defaultValue: import_zod11.z.unknown().optional(),
-  nullable: import_zod11.z.boolean().optional().default(true),
-  unique: import_zod11.z.boolean().optional().default(false),
-  indexed: import_zod11.z.boolean().optional().default(false),
-  searchable: import_zod11.z.boolean().optional().default(false),
-  length: import_zod11.z.number().int().positive().optional(),
-  precision: import_zod11.z.number().int().positive().optional(),
-  scale: import_zod11.z.number().int().min(0).optional(),
-  special: import_zod11.z.array(import_zod11.z.string()).optional(),
-  options: import_zod11.z.record(import_zod11.z.unknown()).optional(),
-  displayOptions: import_zod11.z.record(import_zod11.z.unknown()).optional(),
-  conditions: import_zod11.z.array(import_zod11.z.unknown()).optional(),
-  required: import_zod11.z.boolean().optional().default(false),
-  readonly: import_zod11.z.boolean().optional().default(false),
-  hidden: import_zod11.z.boolean().optional().default(false),
-  encrypted: import_zod11.z.boolean().optional().default(false),
-  versioned: import_zod11.z.boolean().optional().default(false),
-  width: import_zod11.z.enum(["half", "full", "fill"]).optional().default("full"),
-  group: import_zod11.z.string().optional(),
-  sortOrder: import_zod11.z.number().int().optional(),
+  display: import_zod13.z.string().optional(),
+  label: import_zod13.z.string().optional(),
+  note: import_zod13.z.string().optional(),
+  defaultValue: import_zod13.z.unknown().optional(),
+  nullable: import_zod13.z.boolean().optional().default(true),
+  unique: import_zod13.z.boolean().optional().default(false),
+  indexed: import_zod13.z.boolean().optional().default(false),
+  searchable: import_zod13.z.boolean().optional().default(false),
+  length: import_zod13.z.number().int().positive().optional(),
+  precision: import_zod13.z.number().int().positive().optional(),
+  scale: import_zod13.z.number().int().min(0).optional(),
+  special: import_zod13.z.array(import_zod13.z.string()).optional(),
+  options: import_zod13.z.record(import_zod13.z.unknown()).optional(),
+  displayOptions: import_zod13.z.record(import_zod13.z.unknown()).optional(),
+  conditions: import_zod13.z.array(import_zod13.z.unknown()).optional(),
+  required: import_zod13.z.boolean().optional().default(false),
+  readonly: import_zod13.z.boolean().optional().default(false),
+  hidden: import_zod13.z.boolean().optional().default(false),
+  encrypted: import_zod13.z.boolean().optional().default(false),
+  versioned: import_zod13.z.boolean().optional().default(false),
+  width: import_zod13.z.enum(["half", "full", "fill"]).optional().default("full"),
+  group: import_zod13.z.string().optional(),
+  sortOrder: import_zod13.z.number().int().optional(),
   renameFrom: fieldNameSchema.optional().describe("Previous field name if this is a rename operation"),
-  confirmRiskyChange: import_zod11.z.boolean().optional().describe("Set true to confirm type-change or destructive migration")
+  confirmRiskyChange: import_zod13.z.boolean().optional().describe("Set true to confirm type-change or destructive migration")
 });
 function formatError3(err) {
   if (err instanceof LumiBaseApiError) {
@@ -1245,8 +1385,8 @@ function registerFieldTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         field_name: fieldNameSchema,
-        confirm: import_zod11.z.literal(true).describe("Must be true to confirm destructive operation"),
-        force: import_zod11.z.boolean().optional().describe("Force deletion even if risky (foreign keys, etc.)")
+        confirm: import_zod13.z.literal(true).describe("Must be true to confirm destructive operation"),
+        force: import_zod13.z.boolean().optional().describe("Force deletion even if risky (foreign keys, etc.)")
       }
     },
     async ({ collection, field_name, force }) => {
@@ -1265,8 +1405,91 @@ function registerFieldTools(server, client) {
   );
 }
 
+// src/tools/insights.ts
+var import_zod14 = require("zod");
+var AGGREGATES = ["count", "sum", "avg", "min", "max"];
+var dateRangeSchema = import_zod14.z.object({
+  field: import_zod14.z.string().min(1),
+  gte: import_zod14.z.string().optional(),
+  lte: import_zod14.z.string().optional(),
+  preset: import_zod14.z.string().optional()
+}).describe("Restrict the query to a date window on the given field.");
+var panelQueryShape = {
+  collection: import_zod14.z.string().min(1),
+  aggregate: import_zod14.z.enum(AGGREGATES).describe("Aggregate function. `field` is required for everything except `count`."),
+  field: import_zod14.z.string().min(1).optional().describe("Field to aggregate (required unless aggregate=count)."),
+  groupBy: import_zod14.z.string().min(1).optional().describe("Field to group rows by (produces a series)."),
+  filter: import_zod14.z.record(import_zod14.z.unknown()).optional().describe('Directus-style condition rule, e.g. { status: { _eq: "published" } }.'),
+  dateRange: dateRangeSchema.optional(),
+  limit: import_zod14.z.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: import_zod14.z.record(import_zod14.z.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
-var import_zod12 = require("zod");
+var import_zod15 = require("zod");
 function formatError4(err) {
   if (err instanceof LumiBaseApiError) {
     return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
@@ -1288,12 +1511,12 @@ function registerItemTools(server, client) {
       description: "List items from a collection with optional filtering, sorting, and pagination.",
       inputSchema: {
         collection: collectionNameSchema,
-        limit: import_zod12.z.number().int().min(1).max(200).optional().default(25),
-        offset: import_zod12.z.number().int().min(0).optional().default(0),
-        status: import_zod12.z.enum(["draft", "published", "archived"]).optional(),
-        sort: import_zod12.z.string().optional().describe('Comma-separated field names; prefix with - for descending (e.g. "-created_at")'),
-        fields: import_zod12.z.string().optional().describe('Comma-separated field names to return (e.g. "id,title,status")'),
-        search: import_zod12.z.string().optional().describe("Full-text search across searchable fields")
+        limit: import_zod15.z.number().int().min(1).max(200).optional().default(25),
+        offset: import_zod15.z.number().int().min(0).optional().default(0),
+        status: import_zod15.z.enum(["draft", "published", "archived"]).optional(),
+        sort: import_zod15.z.string().optional().describe('Comma-separated field names; prefix with - for descending (e.g. "-created_at")'),
+        fields: import_zod15.z.string().optional().describe('Comma-separated field names to return (e.g. "id,title,status")'),
+        search: import_zod15.z.string().optional().describe("Full-text search across searchable fields")
       }
     },
     async ({ collection, ...params }) => {
@@ -1313,7 +1536,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        fields: import_zod12.z.string().optional().describe("Comma-separated field names to return")
+        fields: import_zod15.z.string().optional().describe("Comma-separated field names to return")
       }
     },
     async ({ collection, id, fields }) => {
@@ -1334,8 +1557,8 @@ function registerItemTools(server, client) {
       description: "Create a new item in a collection.",
       inputSchema: {
         collection: collectionNameSchema,
-        data: import_zod12.z.record(import_zod12.z.unknown()).describe("Field values for the new item"),
-        status: import_zod12.z.enum(["draft", "published"]).optional().default("draft")
+        data: import_zod15.z.record(import_zod15.z.unknown()).describe("Field values for the new item"),
+        status: import_zod15.z.enum(["draft", "published"]).optional().default("draft")
       }
     },
     async ({ collection, data: itemData, status }) => {
@@ -1357,7 +1580,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        data: import_zod12.z.record(import_zod12.z.unknown()).describe("Fields to update")
+        data: import_zod15.z.record(import_zod15.z.unknown()).describe("Fields to update")
       }
     },
     async ({ collection, id, data: itemData }) => {
@@ -1379,7 +1602,7 @@ function registerItemTools(server, client) {
       inputSchema: {
         collection: collectionNameSchema,
         id: idPathSegmentSchema,
-        confirm: import_zod12.z.literal(true).describe("Must be true to confirm deletion")
+        confirm: import_zod15.z.literal(true).describe("Must be true to confirm deletion")
       }
     },
     async ({ collection, id }) => {
@@ -1393,16 +1616,137 @@ function registerItemTools(server, client) {
   );
 }
 
+// src/tools/releases.ts
+var import_zod16 = require("zod");
+var releaseItemSchema = import_zod16.z.object({
+  collection: import_zod16.z.string().min(1),
+  itemId: import_zod16.z.string().min(1),
+  targetStatus: import_zod16.z.enum(["draft", "published", "archived"]).optional(),
+  revisionId: import_zod16.z.string().nullable().optional()
+});
+function registerReleaseTools(server, client) {
+  server.registerTool(
+    "list_releases",
+    {
+      description: "List content releases for the site, optionally filtered by status.",
+      inputSchema: {
+        status: import_zod16.z.string().optional(),
+        page: import_zod16.z.number().int().min(1).optional(),
+        limit: import_zod16.z.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: import_zod16.z.string().min(1),
+        description: import_zod16.z.string().nullable().optional(),
+        atomicityMode: import_zod16.z.enum(["all_or_nothing", "best_effort"]).optional(),
+        publishAt: import_zod16.z.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: import_zod16.z.string().min(1).optional(),
+        description: import_zod16.z.string().nullable().optional(),
+        atomicityMode: import_zod16.z.enum(["all_or_nothing", "best_effort"]).optional(),
+        publishAt: import_zod16.z.string().nullable().optional(),
+        addItems: import_zod16.z.array(releaseItemSchema).optional().describe("Items to stage into the release."),
+        removeItems: import_zod16.z.array(import_zod16.z.object({ collection: import_zod16.z.string(), itemId: import_zod16.z.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: import_zod16.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/releases/${encodePathSegment(id)}`);
+      return okText(`Release "${id}" deleted.`);
+    })
+  );
+}
+
+// src/tools/shares.ts
+var import_zod17 = require("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: import_zod17.z.string().min(1),
+        itemId: import_zod17.z.string().min(1),
+        roleId: import_zod17.z.string().min(1).describe("Role whose permissions the link is viewed through."),
+        password: import_zod17.z.string().min(1).optional(),
+        validFrom: import_zod17.z.string().datetime().nullable().optional(),
+        validUntil: import_zod17.z.string().datetime().nullable().optional(),
+        maxUses: import_zod17.z.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: import_zod17.z.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
-var import_zod13 = require("zod");
+var import_zod18 = require("zod");
 function registerOpsTools(server, client) {
   server.registerTool(
     "list_activity",
     {
       description: "List the site activity / audit trail (most recent first).",
       inputSchema: {
-        limit: import_zod13.z.number().int().min(1).max(500).optional(),
-        offset: import_zod13.z.number().int().min(0).optional()
+        limit: import_zod18.z.number().int().min(1).max(500).optional(),
+        offset: import_zod18.z.number().int().min(0).optional()
       }
     },
     async (args) => run(
@@ -1411,6 +1755,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: {} },
@@ -1424,7 +1776,7 @@ function registerOpsTools(server, client) {
 }
 
 // src/tools/permissions.ts
-var import_zod14 = require("zod");
+var import_zod19 = require("zod");
 function registerPermissionTools(server, client) {
   server.registerTool(
     "get_my_permissions",
@@ -1439,9 +1791,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: import_zod14.z.string().min(1),
-        action: import_zod14.z.enum(["create", "read", "update", "delete", "share"]),
-        item: import_zod14.z.record(import_zod14.z.unknown()).optional().describe("Item payload to evaluate row-level rules against.")
+        collection: import_zod19.z.string().min(1),
+        action: import_zod19.z.enum(["create", "read", "update", "delete", "share"]),
+        item: import_zod19.z.record(import_zod19.z.unknown()).optional().describe("Item payload to evaluate row-level rules against.")
       }
     },
     async (input) => run(() => client.post("/permissions/check", input))
@@ -1449,21 +1801,21 @@ function registerPermissionTools(server, client) {
 }
 
 // src/tools/relations.ts
-var import_zod15 = require("zod");
+var import_zod20 = require("zod");
 var relationInputSchema = {
-  manyCollection: import_zod15.z.string().min(1).describe('Collection that holds the foreign key (the "many" side).'),
-  manyField: import_zod15.z.string().min(1).describe("Field on manyCollection that stores the relation."),
-  oneCollection: import_zod15.z.string().min(1).describe('Related collection (the "one" side).'),
-  oneField: import_zod15.z.string().nullable().optional(),
-  junctionCollection: import_zod15.z.string().nullable().optional().describe("Junction table for m2m relations."),
-  type: import_zod15.z.enum(["m2o", "o2m", "m2m", "m2a"]).optional(),
-  aliasField: import_zod15.z.string().nullable().optional(),
-  relatedDisplayTemplate: import_zod15.z.string().nullable().optional(),
-  junctionManyField: import_zod15.z.string().nullable().optional(),
-  junctionOneField: import_zod15.z.string().nullable().optional(),
-  sortField: import_zod15.z.string().nullable().optional(),
-  onDelete: import_zod15.z.enum(["restrict", "cascade", "set null", "no action"]).optional(),
-  meta: import_zod15.z.record(import_zod15.z.unknown()).optional()
+  manyCollection: import_zod20.z.string().min(1).describe('Collection that holds the foreign key (the "many" side).'),
+  manyField: import_zod20.z.string().min(1).describe("Field on manyCollection that stores the relation."),
+  oneCollection: import_zod20.z.string().min(1).describe('Related collection (the "one" side).'),
+  oneField: import_zod20.z.string().nullable().optional(),
+  junctionCollection: import_zod20.z.string().nullable().optional().describe("Junction table for m2m relations."),
+  type: import_zod20.z.enum(["m2o", "o2m", "m2m", "m2a"]).optional(),
+  aliasField: import_zod20.z.string().nullable().optional(),
+  relatedDisplayTemplate: import_zod20.z.string().nullable().optional(),
+  junctionManyField: import_zod20.z.string().nullable().optional(),
+  junctionOneField: import_zod20.z.string().nullable().optional(),
+  sortField: import_zod20.z.string().nullable().optional(),
+  onDelete: import_zod20.z.enum(["restrict", "cascade", "set null", "no action"]).optional(),
+  meta: import_zod20.z.record(import_zod20.z.unknown()).optional()
 };
 function registerRelationTools(server, client) {
   server.registerTool(
@@ -1485,7 +1837,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: import_zod15.z.literal(true).describe(confirmDescription)
+        confirm: import_zod20.z.literal(true).describe(confirmDescription)
       }
     },
     async ({ id }) => run(async () => {
@@ -1496,19 +1848,19 @@ function registerRelationTools(server, client) {
 }
 
 // src/tools/search-media.ts
-var import_zod16 = require("zod");
+var import_zod21 = require("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: import_zod16.z.string().min(1).describe("Query string."),
-        collection: import_zod16.z.string().min(1).describe("Collection to search."),
-        filter: import_zod16.z.string().optional().describe("Backend filter expression."),
-        sort: import_zod16.z.string().optional().describe("Comma-separated sort fields."),
-        limit: import_zod16.z.number().int().min(1).max(200).optional(),
-        offset: import_zod16.z.number().int().min(0).optional()
+        q: import_zod21.z.string().min(1).describe("Query string."),
+        collection: import_zod21.z.string().min(1).describe("Collection to search."),
+        filter: import_zod21.z.string().optional().describe("Backend filter expression."),
+        sort: import_zod21.z.string().optional().describe("Comma-separated sort fields."),
+        limit: import_zod21.z.number().int().min(1).max(200).optional(),
+        offset: import_zod21.z.number().int().min(0).optional()
       }
     },
     async (args) => run(
@@ -1521,7 +1873,7 @@ function registerSearchMediaTools(server, client) {
     "list_media",
     {
       description: "List media asset keys, optionally filtered by key prefix.",
-      inputSchema: { prefix: import_zod16.z.string().optional() }
+      inputSchema: { prefix: import_zod21.z.string().optional() }
     },
     async ({ prefix }) => run(() => client.get(`/media${prefix ? `?prefix=${encodeURIComponent(prefix)}` : ""}`))
   );
@@ -1531,7 +1883,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: import_zod16.z.literal(true).describe(confirmDescription)
+        confirm: import_zod21.z.literal(true).describe(confirmDescription)
       }
     },
     async ({ key }) => run(async () => {
@@ -1539,18 +1891,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
-var import_zod17 = require("zod");
+var import_zod22 = require("zod");
 function registerTranslationMemoryTools(server, client) {
   server.registerTool(
     "list_tm",
     {
       description: "List translation-memory entries, optionally filtered by source/target language.",
       inputSchema: {
-        source: import_zod17.z.string().optional().describe("Source language code."),
-        target: import_zod17.z.string().optional().describe("Target language code.")
+        source: import_zod22.z.string().optional().describe("Source language code."),
+        target: import_zod22.z.string().optional().describe("Target language code.")
       }
     },
     async (args) => run(
@@ -1562,14 +1922,14 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Add or update a translation-memory entry.",
       inputSchema: {
-        sourceLang: import_zod17.z.string().min(2),
-        targetLang: import_zod17.z.string().min(2),
-        sourceText: import_zod17.z.string().min(1),
-        targetText: import_zod17.z.string().min(1),
-        context: import_zod17.z.string().optional(),
-        quality: import_zod17.z.number().min(0).max(100).optional(),
-        source: import_zod17.z.enum(["human", "mt", "imported"]).optional(),
-        provider: import_zod17.z.string().optional()
+        sourceLang: import_zod22.z.string().min(2),
+        targetLang: import_zod22.z.string().min(2),
+        sourceText: import_zod22.z.string().min(1),
+        targetText: import_zod22.z.string().min(1),
+        context: import_zod22.z.string().optional(),
+        quality: import_zod22.z.number().min(0).max(100).optional(),
+        source: import_zod22.z.enum(["human", "mt", "imported"]).optional(),
+        provider: import_zod22.z.string().optional()
       }
     },
     async (input) => run(() => client.post("/tm", input))
@@ -1579,10 +1939,10 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Fuzzy-match a query string against translation memory for a language pair.",
       inputSchema: {
-        query: import_zod17.z.string().min(1),
-        sourceLang: import_zod17.z.string().min(2),
-        targetLang: import_zod17.z.string().min(2),
-        threshold: import_zod17.z.number().min(0).max(100).optional().describe("Minimum match score (default 75).")
+        query: import_zod22.z.string().min(1),
+        sourceLang: import_zod22.z.string().min(2),
+        targetLang: import_zod22.z.string().min(2),
+        threshold: import_zod22.z.number().min(0).max(100).optional().describe("Minimum match score (default 75).")
       }
     },
     async (input) => run(() => client.post("/tm/lookup", input))
@@ -1592,18 +1952,46 @@ function registerTranslationMemoryTools(server, client) {
     {
       description: "Run the full translation pipeline (TM + glossary + MT provider) for a text.",
       inputSchema: {
-        text: import_zod17.z.string().min(1),
-        from: import_zod17.z.string().min(2),
-        to: import_zod17.z.string().min(2),
-        provider: import_zod17.z.string().optional()
+        text: import_zod22.z.string().min(1),
+        from: import_zod22.z.string().min(2),
+        to: import_zod22.z.string().min(2),
+        provider: import_zod22.z.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: import_zod22.z.string().min(1).optional(),
+        quality: import_zod22.z.number().min(0).max(100).optional(),
+        context: import_zod22.z.string().nullable().optional(),
+        source: import_zod22.z.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: import_zod22.z.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
-var import_zod18 = require("zod");
+var import_zod23 = require("zod");
 function registerUsersTeamsTools(server, client) {
   server.registerTool(
     "list_users",
@@ -1620,8 +2008,8 @@ function registerUsersTeamsTools(server, client) {
     {
       description: "Invite a user to the site by email, optionally assigning a role. Sends an invite email.",
       inputSchema: {
-        email: import_zod18.z.string().email(),
-        roleId: import_zod18.z.string().optional()
+        email: import_zod23.z.string().email(),
+        roleId: import_zod23.z.string().optional()
       }
     },
     async (input) => run(() => client.post("/users/invite", input))
@@ -1632,8 +2020,8 @@ function registerUsersTeamsTools(server, client) {
       description: "Update a user's site membership (role and/or status).",
       inputSchema: {
         id: idPathSegmentSchema,
-        roleId: import_zod18.z.string().nullable().optional(),
-        status: import_zod18.z.string().optional().describe("e.g. active, suspended.")
+        roleId: import_zod23.z.string().nullable().optional(),
+        status: import_zod23.z.string().optional().describe("e.g. active, suspended.")
       }
     },
     async ({ id, ...patch }) => run(() => client.patch(`/users/${encodePathSegment(id)}`, patch))
@@ -1642,7 +2030,7 @@ function registerUsersTeamsTools(server, client) {
     "remove_user",
     {
       description: "Remove a user from the site. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: import_zod18.z.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: import_zod23.z.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/users/${encodePathSegment(id)}`);
@@ -1663,7 +2051,7 @@ function registerUsersTeamsTools(server, client) {
     "create_team",
     {
       description: "Create a team.",
-      inputSchema: { name: import_zod18.z.string().min(1).max(128), description: import_zod18.z.string().nullable().optional() }
+      inputSchema: { name: import_zod23.z.string().min(1).max(128), description: import_zod23.z.string().nullable().optional() }
     },
     async (input) => run(() => client.post("/teams", input))
   );
@@ -1673,8 +2061,8 @@ function registerUsersTeamsTools(server, client) {
       description: "Update a team (partial PATCH).",
       inputSchema: {
         id: idPathSegmentSchema,
-        name: import_zod18.z.string().min(1).max(128).optional(),
-        description: import_zod18.z.string().nullable().optional()
+        name: import_zod23.z.string().min(1).max(128).optional(),
+        description: import_zod23.z.string().nullable().optional()
       }
     },
     async ({ id, ...patch }) => run(() => client.patch(`/teams/${encodePathSegment(id)}`, patch))
@@ -1683,7 +2071,7 @@ function registerUsersTeamsTools(server, client) {
     "delete_team",
     {
       description: "Delete a team. DESTRUCTIVE \u2014 pass confirm=true.",
-      inputSchema: { id: idPathSegmentSchema, confirm: import_zod18.z.literal(true).describe(confirmDescription) }
+      inputSchema: { id: idPathSegmentSchema, confirm: import_zod23.z.literal(true).describe(confirmDescription) }
     },
     async ({ id }) => run(async () => {
       await client.delete(`/teams/${encodePathSegment(id)}`);
@@ -1710,7 +2098,7 @@ function registerUsersTeamsTools(server, client) {
       inputSchema: {
         id: idPathSegmentSchema.describe("Team id."),
         userId: idPathSegmentSchema,
-        confirm: import_zod18.z.literal(true).describe(confirmDescription)
+        confirm: import_zod23.z.literal(true).describe(confirmDescription)
       }
     },
     async ({ id, userId }) => run(async () => {
@@ -1721,15 +2109,15 @@ function registerUsersTeamsTools(server, client) {
 }
 
 // src/tools/webhooks.ts
-var import_zod19 = require("zod");
-var webhookSchema = import_zod19.z.object({
-  name: import_zod19.z.string().min(1).max(255),
-  url: import_zod19.z.string().url(),
-  actions: import_zod19.z.array(import_zod19.z.string()).optional().describe("Item events that trigger the webhook (e.g. create, update, delete)."),
-  collections: import_zod19.z.array(import_zod19.z.string()).optional().describe("Collections to filter on (empty = all)."),
-  headers: import_zod19.z.record(import_zod19.z.string()).optional(),
-  status: import_zod19.z.enum(["active", "inactive"]).optional(),
-  secret: import_zod19.z.string().nullable().optional()
+var import_zod24 = require("zod");
+var webhookSchema = import_zod24.z.object({
+  name: import_zod24.z.string().min(1).max(255),
+  url: import_zod24.z.string().url(),
+  actions: import_zod24.z.array(import_zod24.z.string()).optional().describe("Item events that trigger the webhook (e.g. create, update, delete)."),
+  collections: import_zod24.z.array(import_zod24.z.string()).optional().describe("Collections to filter on (empty = all)."),
+  headers: import_zod24.z.record(import_zod24.z.string()).optional(),
+  status: import_zod24.z.enum(["active", "inactive"]).optional(),
+  secret: import_zod24.z.string().nullable().optional()
 });
 function registerWebhookTools(server, client) {
   registerCrud(server, client, {
@@ -1752,6 +2140,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);
@@ -1762,6 +2154,7 @@ function registerAllTools(server, client) {
   registerOpsTools(server, client);
   registerAdminTools(server, client);
   registerExtensionTools(server, client);
+  registerDeploymentTools(server, client);
 }
 
 // src/index.ts