@lumibase/mcp-server 0.10.0

package/dist/index.cjs

@@ -0,0 +1,1695 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/client.ts
+var LumiBaseApiError = class extends Error {
+  constructor(status, errors) {
+    super(errors[0]?.message ?? `HTTP ${status}`);
+    this.status = status;
+    this.errors = errors;
+    this.name = "LumiBaseApiError";
+  }
+  status;
+  errors;
+};
+var LumiBaseClient = class {
+  baseUrl;
+  origin;
+  headers;
+  constructor(config) {
+    this.origin = config.url.replace(/\/$/, "");
+    this.baseUrl = this.origin + "/api/v1";
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.token}`,
+      "X-Lumi-Site": config.siteId
+    };
+  }
+  async request(method, path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: this.headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (res.status === 204) return void 0;
+    const json = await res.json();
+    if (!res.ok) {
+      throw new LumiBaseApiError(res.status, json.errors ?? [{ code: "UNKNOWN", message: `HTTP ${res.status}` }]);
+    }
+    return json.data;
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+  /**
+   * GET a root-level (non-`/api/v1`) endpoint such as `/health` or `/metrics`
+   * and return the raw response body as text. These endpoints are not
+   * tenant-scoped and do not use the `{data}` envelope.
+   */
+  getRootText(path) {
+    return this.textRequest(`${this.origin}${path}`, "GET");
+  }
+  /** GET an `/api/v1` endpoint that returns a non-JSON body (e.g. NDJSON backup). */
+  getText(path) {
+    return this.textRequest(`${this.baseUrl}${path}`, "GET");
+  }
+  async textRequest(url, method) {
+    const res = await fetch(url, { method, headers: this.headers });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new LumiBaseApiError(res.status, [
+        { code: "HTTP", message: `HTTP ${res.status}: ${text.slice(0, 200)}` }
+      ]);
+    }
+    return text;
+  }
+  /**
+   * POST a raw (non-JSON) request body to an `/api/v1` endpoint and unwrap the
+   * `{data}` envelope from the JSON response (e.g. the NDJSON restore endpoint).
+   */
+  async postRaw(path, body, contentType = "application/x-ndjson") {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": contentType },
+      body
+    });
+    if (res.status === 204) return void 0;
+    const json = await res.json();
+    if (!res.ok) {
+      throw new LumiBaseApiError(res.status, json.errors ?? [{ code: "UNKNOWN", message: `HTTP ${res.status}` }]);
+    }
+    return json.data;
+  }
+};
+function configFromEnv() {
+  const url = process.env["LUMIBASE_URL"];
+  const siteId = process.env["LUMIBASE_SITE_ID"];
+  const token = process.env["LUMIBASE_TOKEN"];
+  if (!url || !siteId || !token) {
+    throw new Error(
+      "Missing required env vars: LUMIBASE_URL, LUMIBASE_SITE_ID, LUMIBASE_TOKEN"
+    );
+  }
+  return { url, siteId, token };
+}
+
+// src/tools/access.ts
+var import_zod2 = require("zod");
+
+// src/tools/_crud.ts
+var import_zod = require("zod");
+
+// src/tools/_shared.ts
+function formatError(err) {
+  if (err instanceof LumiBaseApiError) {
+    return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
+  }
+  return String(err);
+}
+function buildQs(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function okText(text) {
+  return { content: [{ type: "text", text }] };
+}
+function fail(err) {
+  return { content: [{ type: "text", text: `Error: ${formatError(err)}` }], isError: true };
+}
+async function run(fn) {
+  try {
+    const result = await fn();
+    if (result && typeof result === "object" && "content" in result) {
+      return result;
+    }
+    if (typeof result === "string") {
+      return okText(result);
+    }
+    return ok(result);
+  } catch (err) {
+    return fail(err);
+  }
+}
+var confirmDescription = "Must be true to confirm the destructive operation";
+
+// src/tools/_crud.ts
+function registerCrud(server, client, opts) {
+  const {
+    basePath,
+    resource,
+    namePrefix,
+    listName = `list_${namePrefix}s`,
+    createSchema,
+    updateSchema,
+    listQuery,
+    enableDelete = true,
+    enableGet = true,
+    idParam = "id"
+  } = opts;
+  server.registerTool(
+    listName,
+    {
+      description: `List ${resource}s for the current site.`,
+      inputSchema: listQuery ?? {}
+    },
+    async (args) => run(() => {
+      const qs = buildQs(args);
+      return client.get(`${basePath}${qs}`);
+    })
+  );
+  if (enableGet) {
+    server.registerTool(
+      `get_${namePrefix}`,
+      {
+        description: `Get a single ${resource} by ${idParam}.`,
+        inputSchema: { [idParam]: import_zod.z.string().min(1) }
+      },
+      async (args) => run(() => client.get(`${basePath}/${String(args[idParam])}`))
+    );
+  }
+  if (createSchema) {
+    server.registerTool(
+      `create_${namePrefix}`,
+      {
+        description: `Create a new ${resource}.`,
+        inputSchema: createSchema
+      },
+      async (args) => run(() => client.post(basePath, args))
+    );
+  }
+  if (updateSchema) {
+    server.registerTool(
+      `update_${namePrefix}`,
+      {
+        description: `Update an existing ${resource} (partial PATCH).`,
+        inputSchema: { [idParam]: import_zod.z.string().min(1), ...updateSchema }
+      },
+      async (args) => {
+        const { [idParam]: id, ...patch } = args;
+        return run(() => client.patch(`${basePath}/${String(id)}`, patch));
+      }
+    );
+  }
+  if (enableDelete) {
+    server.registerTool(
+      `delete_${namePrefix}`,
+      {
+        description: `Delete a ${resource}. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.`,
+        inputSchema: {
+          [idParam]: import_zod.z.string().min(1),
+          confirm: import_zod.z.literal(true).describe(confirmDescription)
+        }
+      },
+      async (args) => {
+        const id = String(args[idParam]);
+        return run(async () => {
+          await client.delete(`${basePath}/${id}`);
+          return okText(`${resource} "${id}" deleted.`);
+        });
+      }
+    );
+  }
+}
+
+// src/tools/access.ts
+var roleSchema = import_zod2.z.object({
+  key: import_zod2.z.string().min(1).max(96).optional(),
+  systemKey: import_zod2.z.string().min(1).max(96).optional(),
+  name: import_zod2.z.string().min(1).max(64),
+  description: import_zod2.z.string().max(512).optional(),
+  icon: import_zod2.z.string().max(64).optional(),
+  parentId: import_zod2.z.string().nullable().optional(),
+  adminAccess: import_zod2.z.boolean().optional(),
+  appAccess: import_zod2.z.boolean().optional()
+});
+var policySchema = import_zod2.z.object({
+  key: import_zod2.z.string().min(1).max(96).optional(),
+  name: import_zod2.z.string().min(1).max(64),
+  icon: import_zod2.z.string().max(64).optional(),
+  description: import_zod2.z.string().max(512).optional(),
+  adminAccess: import_zod2.z.boolean().optional(),
+  appAccess: import_zod2.z.boolean().optional(),
+  enforceTfa: import_zod2.z.boolean().optional(),
+  ipAllow: import_zod2.z.array(import_zod2.z.string()).optional(),
+  ipDeny: import_zod2.z.array(import_zod2.z.string()).optional(),
+  validFrom: import_zod2.z.string().datetime().nullable().optional(),
+  validUntil: import_zod2.z.string().datetime().nullable().optional(),
+  rules: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var permissionSchema = import_zod2.z.object({
+  collection: import_zod2.z.string().min(1).max(64),
+  action: import_zod2.z.enum(["create", "read", "update", "delete", "share"]),
+  permissions: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  validation: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  presets: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  fields: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+function registerAccessTools(server, client) {
+  registerCrud(server, client, {
+    basePath: "/roles",
+    resource: "role",
+    namePrefix: "role",
+    createSchema: roleSchema.shape,
+    updateSchema: roleSchema.partial().shape
+  });
+  server.registerTool(
+    "attach_role_policy",
+    {
+      description: "Attach a policy to a role. Conflicts/warnings may require overrideWarnings=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Role id."),
+        policyId: import_zod2.z.string().min(1),
+        priority: import_zod2.z.number().int().optional(),
+        overrideWarnings: import_zod2.z.boolean().optional()
+      }
+    },
+    async ({ id, ...body }) => run(() => client.post(`/roles/${id}/policies`, body))
+  );
+  server.registerTool(
+    "detach_role_policy",
+    {
+      description: "Detach a policy from a role. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Role id."),
+        policyId: import_zod2.z.string().min(1),
+        confirm: import_zod2.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, policyId }) => run(async () => {
+      await client.delete(`/roles/${id}/policies/${policyId}`);
+      return okText(`Policy "${policyId}" detached from role "${id}".`);
+    })
+  );
+  server.registerTool(
+    "assign_role_user",
+    {
+      description: "Assign a role to a user (sets the user's primary role for this site).",
+      inputSchema: { id: import_zod2.z.string().min(1).describe("Role id."), userId: import_zod2.z.string().min(1) }
+    },
+    async ({ id, userId }) => run(() => client.post(`/roles/${id}/users`, { userId }))
+  );
+  server.registerTool(
+    "remove_role_user",
+    {
+      description: "Remove a user's role assignment. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Role id."),
+        userId: import_zod2.z.string().min(1),
+        confirm: import_zod2.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, userId }) => run(async () => {
+      await client.delete(`/roles/${id}/users/${userId}`);
+      return okText(`User "${userId}" removed from role "${id}".`);
+    })
+  );
+  registerCrud(server, client, {
+    basePath: "/policies",
+    resource: "policy",
+    namePrefix: "policy",
+    listName: "list_policies",
+    createSchema: policySchema.shape,
+    updateSchema: policySchema.partial().shape
+  });
+  server.registerTool(
+    "add_policy_permission",
+    {
+      description: "Add a permission row (collection + action) to a policy.",
+      inputSchema: { id: import_zod2.z.string().min(1).describe("Policy id."), ...permissionSchema.shape }
+    },
+    async ({ id, ...body }) => run(() => client.post(`/policies/${id}/permissions`, body))
+  );
+  server.registerTool(
+    "update_policy_permission",
+    {
+      description: "Update a permission row on a policy (partial PATCH).",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Policy id."),
+        permId: import_zod2.z.string().min(1).describe("Permission row id."),
+        ...permissionSchema.partial().shape
+      }
+    },
+    async ({ id, permId, ...body }) => run(() => client.patch(`/policies/${id}/permissions/${permId}`, body))
+  );
+  server.registerTool(
+    "delete_policy_permission",
+    {
+      description: "Delete a permission row from a policy. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Policy id."),
+        permId: import_zod2.z.string().min(1).describe("Permission row id."),
+        confirm: import_zod2.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, permId }) => run(async () => {
+      await client.delete(`/policies/${id}/permissions/${permId}`);
+      return okText(`Permission "${permId}" deleted from policy "${id}".`);
+    })
+  );
+  server.registerTool(
+    "attach_policy_user",
+    {
+      description: "Attach a policy directly to a user. Warnings may require overrideWarnings=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Policy id."),
+        userId: import_zod2.z.string().min(1),
+        priority: import_zod2.z.number().int().optional(),
+        overrideWarnings: import_zod2.z.boolean().optional()
+      }
+    },
+    async ({ id, ...body }) => run(() => client.post(`/policies/${id}/users`, body))
+  );
+  server.registerTool(
+    "detach_policy_user",
+    {
+      description: "Detach a policy from a user. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod2.z.string().min(1).describe("Policy id."),
+        userId: import_zod2.z.string().min(1),
+        confirm: import_zod2.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, userId }) => run(async () => {
+      await client.delete(`/policies/${id}/users/${userId}`);
+      return okText(`Policy "${id}" detached from user "${userId}".`);
+    })
+  );
+  server.registerTool(
+    "export_access",
+    { description: "Export the full RBAC manifest (roles, policies, permissions, bindings).", inputSchema: {} },
+    async () => run(() => client.get("/access/export"))
+  );
+  server.registerTool(
+    "dry_run_access_import",
+    {
+      description: "Validate an RBAC manifest import without applying it. Returns the planned changes.",
+      inputSchema: { manifest: import_zod2.z.record(import_zod2.z.unknown()).describe("RBAC manifest from export_access.") }
+    },
+    async ({ manifest }) => run(() => client.post("/access/import?dryRun=true", manifest))
+  );
+  server.registerTool(
+    "apply_access_import",
+    {
+      description: "Apply an RBAC manifest import. High-impact \u2014 changes roles/policies/permissions. Pass confirm=true.",
+      inputSchema: {
+        manifest: import_zod2.z.record(import_zod2.z.unknown()).describe("RBAC manifest from export_access."),
+        mode: import_zod2.z.enum(["merge", "replace-managed", "replace-all"]).optional().describe("Import mode (default merge)."),
+        confirm: import_zod2.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ manifest, mode }) => run(() => client.post(`/access/import${mode ? `?mode=${mode}` : ""}`, manifest))
+  );
+  server.registerTool(
+    "check_access_conflicts",
+    {
+      description: "Check for permission conflicts before attaching/detaching policies on a target.",
+      inputSchema: {
+        target: import_zod2.z.object({ type: import_zod2.z.enum(["role", "user", "api_key"]), id: import_zod2.z.string().min(1) }).describe("The role/user/api_key the policies would apply to."),
+        addPolicies: import_zod2.z.array(import_zod2.z.string()).optional(),
+        removePolicies: import_zod2.z.array(import_zod2.z.string()).optional()
+      }
+    },
+    async (input) => run(() => client.post("/access/conflicts/check", input))
+  );
+}
+
+// src/tools/admin.ts
+var import_zod3 = require("zod");
+var materializeSchema = import_zod3.z.object({
+  collection: import_zod3.z.string().min(1).describe("Source collection name."),
+  target: import_zod3.z.string().regex(/^[a-z][a-z0-9_]{0,62}$/).describe("Physical table name (snake_case)."),
+  refreshStrategy: import_zod3.z.enum(["auto", "cron", "manual"]).optional(),
+  refreshCron: import_zod3.z.string().optional(),
+  projection: import_zod3.z.object({ fields: import_zod3.z.array(import_zod3.z.string()).optional(), orderBy: import_zod3.z.string().optional() }).optional(),
+  filter: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+function registerAdminTools(server, client) {
+  server.registerTool(
+    "export_backup",
+    {
+      description: "Export the full site configuration (collections, fields, RBAC, \u2026) as an NDJSON bundle.",
+      inputSchema: {}
+    },
+    async () => run(async () => okText(await client.getText("/admin/backup")))
+  );
+  server.registerTool(
+    "restore_backup",
+    {
+      description: "Restore a site configuration from an NDJSON bundle (as produced by export_backup). Existing rows are skipped (idempotent). DESTRUCTIVE / high-impact \u2014 pass confirm=true.",
+      inputSchema: {
+        ndjson: import_zod3.z.string().min(1).describe("Raw NDJSON backup content, one JSON object per line."),
+        confirm: import_zod3.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ ndjson }) => run(() => client.postRaw("/admin/restore", ndjson))
+  );
+  server.registerTool(
+    "list_materializations",
+    { description: "List materialized collections (physical tables).", inputSchema: {} },
+    async () => run(() => client.get("/materialize"))
+  );
+  server.registerTool(
+    "register_materialization",
+    {
+      description: "Register a materialized collection and create its physical table.",
+      inputSchema: materializeSchema.shape
+    },
+    async (input) => run(() => client.post("/materialize", input))
+  );
+  server.registerTool(
+    "refresh_materialization",
+    {
+      description: "Refresh a materialized collection (truncate + re-insert from source).",
+      inputSchema: { id: import_zod3.z.string().min(1) }
+    },
+    async ({ id }) => run(() => client.post(`/materialize/${id}/refresh`, {}))
+  );
+  server.registerTool(
+    "query_materialization",
+    {
+      description: "Query the physical table of a materialized collection directly.",
+      inputSchema: { id: import_zod3.z.string().min(1) }
+    },
+    async ({ id }) => run(() => client.get(`/materialize/${id}/data`))
+  );
+  server.registerTool(
+    "drop_materialization",
+    {
+      description: "Drop a materialized collection (physical table + metadata). DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: { id: import_zod3.z.string().min(1), confirm: import_zod3.z.literal(true).describe(confirmDescription) }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/materialize/${id}`);
+      return okText(`Materialization "${id}" dropped.`);
+    })
+  );
+}
+
+// src/tools/agent.ts
+var import_zod4 = require("zod");
+var intentSchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1).max(120),
+  collection: import_zod4.z.string().min(1).max(120),
+  rules: import_zod4.z.array(import_zod4.z.record(import_zod4.z.unknown())).describe("SLO rules (required_fields, freshness, translations, link_health, \u2026)."),
+  schedule: import_zod4.z.string().describe("5-field cron expression for reconciliation cadence."),
+  budget: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+  autonomyCap: import_zod4.z.number().int().min(0).max(4).optional().describe("Max autonomy level L0\u2013L4 for this intent."),
+  maintenanceWindow: import_zod4.z.record(import_zod4.z.unknown()).nullable().optional()
+});
+var flowNode = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  key: import_zod4.z.string(),
+  options: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+  next: import_zod4.z.string().nullable().optional(),
+  onError: import_zod4.z.string().nullable().optional()
+});
+var flowSchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1),
+  description: import_zod4.z.string().optional(),
+  status: import_zod4.z.enum(["active", "inactive", "draft"]).optional(),
+  triggerType: import_zod4.z.enum(["webhook", "event", "schedule", "manual"]),
+  triggerOptions: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+  graph: import_zod4.z.object({
+    entry: import_zod4.z.string().optional(),
+    nodes: import_zod4.z.array(flowNode).optional()
+  })
+});
+function registerAgentTools(server, client) {
+  registerCrud(server, client, {
+    basePath: "/agent/intents",
+    resource: "intent",
+    namePrefix: "intent",
+    createSchema: intentSchema.shape,
+    updateSchema: intentSchema.partial().shape
+  });
+  server.registerTool(
+    "pause_intent",
+    { description: "Pause an intent (stops scheduled reconciliation).", inputSchema: { id: import_zod4.z.string().min(1) } },
+    async ({ id }) => run(() => client.post(`/agent/intents/${id}/pause`, {}))
+  );
+  server.registerTool(
+    "resume_intent",
+    { description: "Resume a paused intent.", inputSchema: { id: import_zod4.z.string().min(1) } },
+    async ({ id }) => run(() => client.post(`/agent/intents/${id}/resume`, {}))
+  );
+  server.registerTool(
+    "list_intent_drifts",
+    { description: "List detected drifts (intent violations) for an intent.", inputSchema: { id: import_zod4.z.string().min(1) } },
+    async ({ id }) => run(() => client.get(`/agent/intents/${id}/drifts`))
+  );
+  server.registerTool(
+    "scan_intent",
+    { description: "Trigger an on-demand drift scan for an intent.", inputSchema: { id: import_zod4.z.string().min(1) } },
+    async ({ id }) => run(() => client.post(`/agent/intents/${id}/scan`, {}))
+  );
+  server.registerTool(
+    "compile_intent",
+    {
+      description: "Compile a natural-language description into structured intent rules (preview, does not persist).",
+      inputSchema: {
+        description: import_zod4.z.string().min(1).max(4e3),
+        collection: import_zod4.z.string().min(1).max(120)
+      }
+    },
+    async (input) => run(() => client.post("/agent/intents/compile", input))
+  );
+  registerCrud(server, client, {
+    basePath: "/flows",
+    resource: "flow",
+    namePrefix: "flow",
+    createSchema: flowSchema.shape,
+    updateSchema: flowSchema.partial().shape
+  });
+  server.registerTool(
+    "run_flow",
+    {
+      description: "Trigger a manual run of a flow with an optional input payload.",
+      inputSchema: {
+        id: import_zod4.z.string().min(1),
+        input: import_zod4.z.record(import_zod4.z.unknown()).optional().describe("Initial context passed to the flow.")
+      }
+    },
+    async ({ id, input }) => run(() => client.post(`/flows/${id}/run`, input ?? {}))
+  );
+  server.registerTool(
+    "list_flow_runs",
+    { description: "List recent runs of a flow.", inputSchema: { id: import_zod4.z.string().min(1) } },
+    async ({ id }) => run(() => client.get(`/flows/${id}/runs`))
+  );
+}
+
+// src/tools/api-keys.ts
+var import_zod5 = require("zod");
+function registerApiKeyTools(server, client) {
+  server.registerTool(
+    "list_api_keys",
+    { description: "List API keys for the site (token values are never returned).", inputSchema: {} },
+    async () => run(() => client.get("/api-keys"))
+  );
+  server.registerTool(
+    "get_api_key",
+    { description: "Get a single API key by id.", inputSchema: { id: import_zod5.z.string().min(1) } },
+    async ({ id }) => run(() => client.get(`/api-keys/${id}`))
+  );
+  server.registerTool(
+    "create_api_key",
+    {
+      description: "Create a new API key. The plaintext token is returned ONCE in the response \u2014 surface it to the user and tell them it cannot be retrieved again.",
+      inputSchema: {
+        name: import_zod5.z.string().min(1).max(96),
+        description: import_zod5.z.string().max(512).optional(),
+        expiresAt: import_zod5.z.string().datetime().nullable().optional(),
+        metadata: import_zod5.z.record(import_zod5.z.unknown()).optional()
+      }
+    },
+    async (input) => run(() => client.post("/api-keys", input))
+  );
+  server.registerTool(
+    "rotate_api_key",
+    {
+      description: "Rotate an API key \u2014 issues a new token (returned once) and invalidates the old one. DESTRUCTIVE for existing integrations \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod5.z.string().min(1),
+        expiresAt: import_zod5.z.string().datetime().nullable().optional(),
+        confirm: import_zod5.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, expiresAt }) => run(() => client.post(`/api-keys/${id}/rotate`, expiresAt !== void 0 ? { expiresAt } : {}))
+  );
+  server.registerTool(
+    "revoke_api_key",
+    {
+      description: "Revoke an API key permanently. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: { id: import_zod5.z.string().min(1), confirm: import_zod5.z.literal(true).describe(confirmDescription) }
+    },
+    async ({ id }) => run(() => client.post(`/api-keys/${id}/revoke`, {}))
+  );
+  server.registerTool(
+    "attach_api_key_role",
+    {
+      description: "Attach a role to an API key (grants the role\u2019s policies to the key).",
+      inputSchema: {
+        id: import_zod5.z.string().min(1).describe("API key id."),
+        roleId: import_zod5.z.string().min(1),
+        priority: import_zod5.z.number().int().optional(),
+        overrideWarnings: import_zod5.z.boolean().optional()
+      }
+    },
+    async ({ id, ...body }) => run(() => client.post(`/api-keys/${id}/roles`, body))
+  );
+  server.registerTool(
+    "detach_api_key_role",
+    {
+      description: "Detach a role from an API key. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod5.z.string().min(1).describe("API key id."),
+        roleId: import_zod5.z.string().min(1),
+        confirm: import_zod5.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, roleId }) => run(async () => {
+      await client.delete(`/api-keys/${id}/roles/${roleId}`);
+      return okText(`Role "${roleId}" detached from API key "${id}".`);
+    })
+  );
+  server.registerTool(
+    "attach_api_key_policy",
+    {
+      description: "Attach a policy directly to an API key.",
+      inputSchema: {
+        id: import_zod5.z.string().min(1).describe("API key id."),
+        policyId: import_zod5.z.string().min(1),
+        priority: import_zod5.z.number().int().optional(),
+        overrideWarnings: import_zod5.z.boolean().optional()
+      }
+    },
+    async ({ id, ...body }) => run(() => client.post(`/api-keys/${id}/policies`, body))
+  );
+  server.registerTool(
+    "detach_api_key_policy",
+    {
+      description: "Detach a policy from an API key. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod5.z.string().min(1).describe("API key id."),
+        policyId: import_zod5.z.string().min(1),
+        confirm: import_zod5.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, policyId }) => run(async () => {
+      await client.delete(`/api-keys/${id}/policies/${policyId}`);
+      return okText(`Policy "${policyId}" detached from API key "${id}".`);
+    })
+  );
+}
+
+// src/tools/collections.ts
+var import_zod6 = require("zod");
+var collectionNameSchema = import_zod6.z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]{0,62}$/, "Must be lowercase, start with a letter, only a-z0-9_");
+var collectionInputSchema = import_zod6.z.object({
+  name: collectionNameSchema,
+  label: import_zod6.z.string().optional(),
+  pluralLabel: import_zod6.z.string().optional(),
+  hidden: import_zod6.z.boolean().optional(),
+  singleton: import_zod6.z.boolean().optional(),
+  icon: import_zod6.z.string().optional(),
+  color: import_zod6.z.string().optional(),
+  note: import_zod6.z.string().optional(),
+  primaryKeyField: import_zod6.z.string().optional(),
+  primaryKeyType: import_zod6.z.enum(["nanoid", "uuid", "integer", "bigInteger", "string"]).optional(),
+  storageMode: import_zod6.z.enum(["jsonb", "materialized", "physical", "external"]).optional(),
+  displayTemplate: import_zod6.z.string().optional(),
+  sortField: import_zod6.z.string().optional(),
+  archiveField: import_zod6.z.string().optional(),
+  archiveValue: import_zod6.z.string().optional(),
+  unarchiveValue: import_zod6.z.string().optional(),
+  accountability: import_zod6.z.enum(["all", "activity", "none"]).optional(),
+  versioning: import_zod6.z.boolean().optional()
+});
+var fieldInputSchema = import_zod6.z.object({
+  name: collectionNameSchema,
+  type: import_zod6.z.string().min(1),
+  interface: import_zod6.z.string().min(1),
+  display: import_zod6.z.string().optional(),
+  label: import_zod6.z.string().optional(),
+  note: import_zod6.z.string().optional(),
+  nullable: import_zod6.z.boolean().optional(),
+  unique: import_zod6.z.boolean().optional(),
+  indexed: import_zod6.z.boolean().optional(),
+  searchable: import_zod6.z.boolean().optional(),
+  required: import_zod6.z.boolean().optional(),
+  readonly: import_zod6.z.boolean().optional(),
+  hidden: import_zod6.z.boolean().optional(),
+  width: import_zod6.z.enum(["half", "full", "fill"]).optional(),
+  sortOrder: import_zod6.z.number().int().optional(),
+  group: import_zod6.z.string().optional(),
+  options: import_zod6.z.record(import_zod6.z.unknown()).optional(),
+  defaultValue: import_zod6.z.unknown().optional()
+});
+function formatError2(err) {
+  if (err instanceof LumiBaseApiError) {
+    return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
+  }
+  return String(err);
+}
+function registerCollectionTools(server, client) {
+  server.registerTool(
+    "list_collections",
+    {
+      description: "List all collections in the LumiBase site.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await client.get("/collections");
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "get_collection",
+    {
+      description: "Get a collection with its compiled schema (all fields, system fields, meta).",
+      inputSchema: { name: import_zod6.z.string().min(1) }
+    },
+    async ({ name }) => {
+      try {
+        const data = await client.get(`/collections/${name}/compiled`);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "create_collection",
+    {
+      description: 'Create a new collection. Name must be lowercase snake_case (e.g. "blog_posts"). storageMode defaults to "jsonb" (recommended for most use-cases). primaryKeyType defaults to "nanoid".',
+      inputSchema: collectionInputSchema.shape
+    },
+    async (input) => {
+      try {
+        const data = await client.post("/collections", input);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "update_collection",
+    {
+      description: "Update metadata on an existing collection (label, icon, note, accountability, etc.).",
+      inputSchema: {
+        name: import_zod6.z.string().min(1),
+        patch: collectionInputSchema.omit({ name: true }).partial()
+      }
+    },
+    async ({ name, patch }) => {
+      try {
+        const data = await client.patch(`/collections/${name}`, patch);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "delete_collection",
+    {
+      description: "Delete a collection and all its items. DESTRUCTIVE \u2014 cannot be undone. You MUST pass confirm=true explicitly after warning the user.",
+      inputSchema: {
+        name: import_zod6.z.string().min(1),
+        confirm: import_zod6.z.literal(true).describe("Must be true to confirm destructive operation")
+      }
+    },
+    async ({ name, confirm: _ }) => {
+      try {
+        await client.delete(`/collections/${name}`);
+        return { content: [{ type: "text", text: `Collection "${name}" deleted.` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "diff_schema",
+    {
+      description: "Preview what would change if you applied a schema update. Returns added/modified/removed fields and any risky changes. Always call this before apply_schema to check for breaking changes.",
+      inputSchema: {
+        name: import_zod6.z.string().min(1),
+        fields: import_zod6.z.array(fieldInputSchema).optional(),
+        label: import_zod6.z.string().optional(),
+        note: import_zod6.z.string().optional()
+      }
+    },
+    async (input) => {
+      try {
+        const data = await client.post("/collections/diff", input);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "apply_schema",
+    {
+      description: "Atomically apply a schema migration to a collection (add/update/remove fields and relations). Call diff_schema first to preview changes. Pass confirmRiskyChange=true on field inputs that have risky changes.",
+      inputSchema: {
+        name: import_zod6.z.string().min(1),
+        fields: import_zod6.z.array(
+          fieldInputSchema.extend({
+            renameFrom: import_zod6.z.string().optional(),
+            confirmRiskyChange: import_zod6.z.boolean().optional()
+          })
+        ).optional(),
+        label: import_zod6.z.string().optional(),
+        note: import_zod6.z.string().optional(),
+        accountability: import_zod6.z.enum(["all", "activity", "none"]).optional(),
+        versioning: import_zod6.z.boolean().optional()
+      }
+    },
+    async (input) => {
+      try {
+        const { name, ...rest } = input;
+        const data = await client.put(`/collections/${name}/schema`, rest);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError2(err)}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/content-config.ts
+var import_zod7 = require("zod");
+var presetSchema = import_zod7.z.object({
+  bookmark: import_zod7.z.string().nullable().optional(),
+  collection: import_zod7.z.string(),
+  userId: import_zod7.z.string().nullable().optional(),
+  roleId: import_zod7.z.string().nullable().optional(),
+  layout: import_zod7.z.string().optional(),
+  layoutQuery: import_zod7.z.record(import_zod7.z.unknown()).optional(),
+  layoutOptions: import_zod7.z.record(import_zod7.z.unknown()).optional(),
+  search: import_zod7.z.string().nullable().optional(),
+  filter: import_zod7.z.record(import_zod7.z.unknown()).optional(),
+  icon: import_zod7.z.string().nullable().optional(),
+  color: import_zod7.z.string().nullable().optional(),
+  refreshInterval: import_zod7.z.number().int().min(0).optional()
+});
+var translationSchema = import_zod7.z.object({
+  language: import_zod7.z.string(),
+  namespace: import_zod7.z.string(),
+  key: import_zod7.z.string(),
+  value: import_zod7.z.string(),
+  status: import_zod7.z.string().optional()
+});
+function registerContentConfigTools(server, client) {
+  registerCrud(server, client, {
+    basePath: "/presets",
+    resource: "preset",
+    namePrefix: "preset",
+    listQuery: { collection: import_zod7.z.string().optional() },
+    createSchema: presetSchema.shape,
+    updateSchema: presetSchema.partial().shape
+  });
+  registerCrud(server, client, {
+    basePath: "/translations",
+    resource: "translation",
+    namePrefix: "translation",
+    listQuery: {
+      namespace: import_zod7.z.string().optional(),
+      language: import_zod7.z.string().optional()
+    },
+    createSchema: translationSchema.shape,
+    updateSchema: translationSchema.partial().shape
+  });
+  server.registerTool(
+    "list_settings",
+    {
+      description: "List site settings, optionally filtered by scope.",
+      inputSchema: { scope: import_zod7.z.string().optional() }
+    },
+    async ({ scope }) => run(() => client.get(`/settings${scope ? `?scope=${encodeURIComponent(scope)}` : ""}`))
+  );
+  server.registerTool(
+    "get_setting",
+    {
+      description: "Get a single setting by key.",
+      inputSchema: { key: import_zod7.z.string().min(1) }
+    },
+    async ({ key }) => run(() => client.get(`/settings/${encodeURIComponent(key)}`))
+  );
+  server.registerTool(
+    "upsert_setting",
+    {
+      description: "Create or update a setting (upsert by key).",
+      inputSchema: {
+        key: import_zod7.z.string().min(1),
+        value: import_zod7.z.record(import_zod7.z.unknown()).describe("Arbitrary JSON value object for the setting."),
+        scope: import_zod7.z.string().optional()
+      }
+    },
+    async (input) => run(() => client.post("/settings", input))
+  );
+  server.registerTool(
+    "delete_setting",
+    {
+      description: "Delete a setting by key. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        key: import_zod7.z.string().min(1),
+        confirm: import_zod7.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ key }) => run(async () => {
+      await client.delete(`/settings/${encodeURIComponent(key)}`);
+      return okText(`Setting "${key}" deleted.`);
+    })
+  );
+}
+
+// src/tools/extensions.ts
+var import_zod8 = require("zod");
+var EXTENSION_TYPES = ["interface", "display", "layout", "panel", "module", "hook", "endpoint"];
+var extensionSchema = import_zod8.z.object({
+  key: import_zod8.z.string().regex(/^[a-z0-9_:-]+$/).optional(),
+  name: import_zod8.z.string().min(1),
+  version: import_zod8.z.string().min(1),
+  type: import_zod8.z.enum(EXTENSION_TYPES),
+  enabled: import_zod8.z.boolean().optional(),
+  bundleUrl: import_zod8.z.string().min(1).describe("https:, http:, or data:text/javascript bundle URL."),
+  manifest: import_zod8.z.record(import_zod8.z.string()).optional(),
+  capabilities: import_zod8.z.array(import_zod8.z.string()).optional()
+});
+function registerExtensionTools(server, client) {
+  server.registerTool(
+    "list_extensions",
+    { description: "List extensions installed on the active site.", inputSchema: {} },
+    async () => run(() => client.get("/extensions"))
+  );
+  server.registerTool(
+    "install_extension",
+    {
+      description: "Install (register) an extension on the active site from a bundle URL.",
+      inputSchema: extensionSchema.shape
+    },
+    async (input) => run(() => client.post("/extensions", input))
+  );
+  server.registerTool(
+    "update_extension",
+    {
+      description: "Update an installed extension (enable/disable, version, config). Partial PATCH.",
+      inputSchema: { id: import_zod8.z.string().min(1), ...extensionSchema.partial().shape }
+    },
+    async ({ id, ...patch }) => run(() => client.patch(`/extensions/${id}`, patch))
+  );
+  server.registerTool(
+    "uninstall_extension",
+    {
+      description: "Uninstall an extension from the site. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: { id: import_zod8.z.string().min(1), confirm: import_zod8.z.literal(true).describe(confirmDescription) }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/extensions/${id}`);
+      return okText(`Extension "${id}" uninstalled.`);
+    })
+  );
+  server.registerTool(
+    "list_marketplace_extensions",
+    {
+      description: "Browse the published extension marketplace.",
+      inputSchema: {
+        q: import_zod8.z.string().optional(),
+        category: import_zod8.z.string().optional(),
+        tags: import_zod8.z.string().optional().describe("Comma-separated tags."),
+        sort: import_zod8.z.string().optional(),
+        page: import_zod8.z.number().int().min(1).optional(),
+        perPage: import_zod8.z.number().int().min(1).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/marketplace/extensions${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "get_marketplace_extension",
+    {
+      description: "Get a single marketplace extension by slug.",
+      inputSchema: { slug: import_zod8.z.string().min(1) }
+    },
+    async ({ slug }) => run(() => client.get(`/marketplace/extensions/${slug}`))
+  );
+  server.registerTool(
+    "list_marketplace_updates",
+    { description: "List available updates for installed marketplace extensions.", inputSchema: {} },
+    async () => run(() => client.get("/marketplace/updates"))
+  );
+  server.registerTool(
+    "install_marketplace_extension",
+    {
+      description: "Install a published marketplace extension onto the active site by slug.",
+      inputSchema: { slug: import_zod8.z.string().min(1) }
+    },
+    async ({ slug }) => run(() => client.post(`/marketplace/extensions/${slug}/install`, {}))
+  );
+  server.registerTool(
+    "publish_extension",
+    {
+      description: "Publish an extension to the marketplace (signs + marks it published).",
+      inputSchema: {
+        extensionId: import_zod8.z.string().min(1),
+        marketplaceSlug: import_zod8.z.string().min(1),
+        publisher: import_zod8.z.record(import_zod8.z.unknown()).optional(),
+        signature: import_zod8.z.string().optional(),
+        signatureAlg: import_zod8.z.string().optional(),
+        publisherKeyId: import_zod8.z.string().optional(),
+        bundleSha256: import_zod8.z.string().optional()
+      }
+    },
+    async (input) => run(() => client.post("/marketplace/publish", input))
+  );
+}
+
+// src/tools/fields.ts
+var import_zod9 = require("zod");
+var namePattern = /^[a-z][a-z0-9_]{0,62}$/;
+var fieldInputSchema2 = import_zod9.z.object({
+  type: import_zod9.z.string().min(1).describe(
+    "Storage type: string, text, integer, bigInteger, float, decimal, boolean, date, dateTime, time, json, uuid, csv, hash, alias"
+  ),
+  interface: import_zod9.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_zod9.z.string().optional(),
+  label: import_zod9.z.string().optional(),
+  note: import_zod9.z.string().optional(),
+  defaultValue: import_zod9.z.unknown().optional(),
+  nullable: import_zod9.z.boolean().optional().default(true),
+  unique: import_zod9.z.boolean().optional().default(false),
+  indexed: import_zod9.z.boolean().optional().default(false),
+  searchable: import_zod9.z.boolean().optional().default(false),
+  length: import_zod9.z.number().int().positive().optional(),
+  precision: import_zod9.z.number().int().positive().optional(),
+  scale: import_zod9.z.number().int().min(0).optional(),
+  special: import_zod9.z.array(import_zod9.z.string()).optional(),
+  options: import_zod9.z.record(import_zod9.z.unknown()).optional(),
+  displayOptions: import_zod9.z.record(import_zod9.z.unknown()).optional(),
+  conditions: import_zod9.z.array(import_zod9.z.unknown()).optional(),
+  required: import_zod9.z.boolean().optional().default(false),
+  readonly: import_zod9.z.boolean().optional().default(false),
+  hidden: import_zod9.z.boolean().optional().default(false),
+  encrypted: import_zod9.z.boolean().optional().default(false),
+  versioned: import_zod9.z.boolean().optional().default(false),
+  width: import_zod9.z.enum(["half", "full", "fill"]).optional().default("full"),
+  group: import_zod9.z.string().optional(),
+  sortOrder: import_zod9.z.number().int().optional(),
+  renameFrom: import_zod9.z.string().regex(namePattern).optional().describe("Previous field name if this is a rename operation"),
+  confirmRiskyChange: import_zod9.z.boolean().optional().describe("Set true to confirm type-change or destructive migration")
+});
+function formatError3(err) {
+  if (err instanceof LumiBaseApiError) {
+    return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
+  }
+  return String(err);
+}
+function registerFieldTools(server, client) {
+  server.registerTool(
+    "list_fields",
+    {
+      description: "List all fields in a collection, including system fields.",
+      inputSchema: {
+        collection: import_zod9.z.string().min(1)
+      }
+    },
+    async ({ collection }) => {
+      try {
+        const data = await client.get(`/collections/${collection}/fields`);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError3(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_field",
+    {
+      description: 'Create or update a field in a collection. field_name must be lowercase snake_case (e.g. "published_at"). Common types: string (varchar), text (longtext), integer, boolean, dateTime, json, uuid. Common interfaces: input, textarea, datetime, toggle, select, file, markdown.',
+      inputSchema: {
+        collection: import_zod9.z.string().min(1),
+        field_name: import_zod9.z.string().regex(namePattern, "Must be lowercase snake_case, start with a letter").describe("Machine name of the field"),
+        ...fieldInputSchema2.shape
+      }
+    },
+    async ({ collection, field_name, ...fieldInput }) => {
+      try {
+        const data = await client.put(
+          `/collections/${collection}/fields/${field_name}`,
+          fieldInput
+        );
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError3(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "delete_field",
+    {
+      description: "Delete a field from a collection. Data stored in this field will be lost. Pass confirm=true to confirm the destructive operation.",
+      inputSchema: {
+        collection: import_zod9.z.string().min(1),
+        field_name: import_zod9.z.string().min(1),
+        confirm: import_zod9.z.literal(true).describe("Must be true to confirm destructive operation"),
+        force: import_zod9.z.boolean().optional().describe("Force deletion even if risky (foreign keys, etc.)")
+      }
+    },
+    async ({ collection, field_name, force }) => {
+      try {
+        const qs = force ? "?force=true" : "";
+        await client.delete(`/collections/${collection}/fields/${field_name}${qs}`);
+        return {
+          content: [{ type: "text", text: `Field "${field_name}" deleted from "${collection}".` }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError3(err)}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/items.ts
+var import_zod10 = require("zod");
+function formatError4(err) {
+  if (err instanceof LumiBaseApiError) {
+    return err.errors.map((e) => `[${e.code}] ${e.message}`).join("; ");
+  }
+  return String(err);
+}
+function buildQs2(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function registerItemTools(server, client) {
+  server.registerTool(
+    "list_items",
+    {
+      description: "List items from a collection with optional filtering, sorting, and pagination.",
+      inputSchema: {
+        collection: import_zod10.z.string().min(1),
+        limit: import_zod10.z.number().int().min(1).max(200).optional().default(25),
+        offset: import_zod10.z.number().int().min(0).optional().default(0),
+        status: import_zod10.z.enum(["draft", "published", "archived"]).optional(),
+        sort: import_zod10.z.string().optional().describe('Comma-separated field names; prefix with - for descending (e.g. "-created_at")'),
+        fields: import_zod10.z.string().optional().describe('Comma-separated field names to return (e.g. "id,title,status")'),
+        search: import_zod10.z.string().optional().describe("Full-text search across searchable fields")
+      }
+    },
+    async ({ collection, ...params }) => {
+      try {
+        const qs = buildQs2(params);
+        const data = await client.get(`/items/${collection}${qs}`);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError4(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "get_item",
+    {
+      description: "Get a single item by ID from a collection.",
+      inputSchema: {
+        collection: import_zod10.z.string().min(1),
+        id: import_zod10.z.string().min(1),
+        fields: import_zod10.z.string().optional().describe("Comma-separated field names to return")
+      }
+    },
+    async ({ collection, id, fields }) => {
+      try {
+        const qs = buildQs2({ fields });
+        const data = await client.get(`/items/${collection}/${id}${qs}`);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError4(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "create_item",
+    {
+      description: "Create a new item in a collection.",
+      inputSchema: {
+        collection: import_zod10.z.string().min(1),
+        data: import_zod10.z.record(import_zod10.z.unknown()).describe("Field values for the new item"),
+        status: import_zod10.z.enum(["draft", "published"]).optional().default("draft")
+      }
+    },
+    async ({ collection, data: itemData, status }) => {
+      try {
+        const data = await client.post(`/items/${collection}`, {
+          ...itemData,
+          status
+        });
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError4(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "update_item",
+    {
+      description: "Partially update an item (PATCH \u2014 only provided fields are changed).",
+      inputSchema: {
+        collection: import_zod10.z.string().min(1),
+        id: import_zod10.z.string().min(1),
+        data: import_zod10.z.record(import_zod10.z.unknown()).describe("Fields to update")
+      }
+    },
+    async ({ collection, id, data: itemData }) => {
+      try {
+        const data = await client.patch(`/items/${collection}/${id}`, itemData);
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError4(err)}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "delete_item",
+    {
+      description: "Soft-delete an item (sets deleted_at, recoverable). Pass confirm=true.",
+      inputSchema: {
+        collection: import_zod10.z.string().min(1),
+        id: import_zod10.z.string().min(1),
+        confirm: import_zod10.z.literal(true).describe("Must be true to confirm deletion")
+      }
+    },
+    async ({ collection, id }) => {
+      try {
+        await client.delete(`/items/${collection}/${id}`);
+        return { content: [{ type: "text", text: `Item "${id}" deleted from "${collection}".` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${formatError4(err)}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/ops.ts
+var import_zod11 = require("zod");
+function registerOpsTools(server, client) {
+  server.registerTool(
+    "list_activity",
+    {
+      description: "List the site activity / audit trail (most recent first).",
+      inputSchema: {
+        limit: import_zod11.z.number().int().min(1).max(500).optional(),
+        offset: import_zod11.z.number().int().min(0).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/activity${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "get_health",
+    { description: "Check the CMS health endpoint.", inputSchema: {} },
+    async () => run(async () => okText(await client.getRootText("/health")))
+  );
+  server.registerTool(
+    "get_metrics",
+    { description: "Fetch Prometheus metrics exposition text from the CMS.", inputSchema: {} },
+    async () => run(async () => okText(await client.getRootText("/metrics")))
+  );
+}
+
+// src/tools/permissions.ts
+var import_zod12 = require("zod");
+function registerPermissionTools(server, client) {
+  server.registerTool(
+    "get_my_permissions",
+    {
+      description: "Get the compiled permission bundle for the authenticated principal.",
+      inputSchema: {}
+    },
+    async () => run(() => client.get("/permissions/me"))
+  );
+  server.registerTool(
+    "check_permission",
+    {
+      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_zod12.z.string().min(1),
+        action: import_zod12.z.enum(["create", "read", "update", "delete", "share"]),
+        item: import_zod12.z.record(import_zod12.z.unknown()).optional().describe("Item payload to evaluate row-level rules against.")
+      }
+    },
+    async (input) => run(() => client.post("/permissions/check", input))
+  );
+}
+
+// src/tools/relations.ts
+var import_zod13 = require("zod");
+var relationInputSchema = {
+  manyCollection: import_zod13.z.string().min(1).describe('Collection that holds the foreign key (the "many" side).'),
+  manyField: import_zod13.z.string().min(1).describe("Field on manyCollection that stores the relation."),
+  oneCollection: import_zod13.z.string().min(1).describe('Related collection (the "one" side).'),
+  oneField: import_zod13.z.string().nullable().optional(),
+  junctionCollection: import_zod13.z.string().nullable().optional().describe("Junction table for m2m relations."),
+  type: import_zod13.z.enum(["m2o", "o2m", "m2m", "m2a"]).optional(),
+  aliasField: import_zod13.z.string().nullable().optional(),
+  relatedDisplayTemplate: import_zod13.z.string().nullable().optional(),
+  junctionManyField: import_zod13.z.string().nullable().optional(),
+  junctionOneField: import_zod13.z.string().nullable().optional(),
+  sortField: import_zod13.z.string().nullable().optional(),
+  onDelete: import_zod13.z.enum(["restrict", "cascade", "set null", "no action"]).optional(),
+  meta: import_zod13.z.record(import_zod13.z.unknown()).optional()
+};
+function registerRelationTools(server, client) {
+  server.registerTool(
+    "list_relations",
+    { description: "List all relations configured in the schema.", inputSchema: {} },
+    async () => run(() => client.get("/relations"))
+  );
+  server.registerTool(
+    "create_relation",
+    {
+      description: "Create a relation between two collections (m2o, o2m, m2m, or m2a). Schema-changing operation.",
+      inputSchema: relationInputSchema
+    },
+    async (input) => run(() => client.post("/relations", input))
+  );
+  server.registerTool(
+    "delete_relation",
+    {
+      description: "Delete a relation by id. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        id: import_zod13.z.string().min(1),
+        confirm: import_zod13.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/relations/${id}`);
+      return okText(`Relation "${id}" deleted.`);
+    })
+  );
+}
+
+// src/tools/search-media.ts
+var import_zod14 = 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_zod14.z.string().min(1).describe("Query string."),
+        collection: import_zod14.z.string().min(1).describe("Collection to search."),
+        filter: import_zod14.z.string().optional().describe("Backend filter expression."),
+        sort: import_zod14.z.string().optional().describe("Comma-separated sort fields."),
+        limit: import_zod14.z.number().int().min(1).max(200).optional(),
+        offset: import_zod14.z.number().int().min(0).optional()
+      }
+    },
+    async (args) => run(
+      () => client.get(
+        `/search${buildQs(args)}`
+      )
+    )
+  );
+  server.registerTool(
+    "list_media",
+    {
+      description: "List media asset keys, optionally filtered by key prefix.",
+      inputSchema: { prefix: import_zod14.z.string().optional() }
+    },
+    async ({ prefix }) => run(() => client.get(`/media${prefix ? `?prefix=${encodeURIComponent(prefix)}` : ""}`))
+  );
+  server.registerTool(
+    "delete_media",
+    {
+      description: "Delete a media asset by key. DESTRUCTIVE \u2014 warn the user first and pass confirm=true.",
+      inputSchema: {
+        key: import_zod14.z.string().min(1).describe("Full storage key of the asset."),
+        confirm: import_zod14.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ key }) => run(async () => {
+      await client.delete(`/media/${key}`);
+      return okText(`Media asset "${key}" deleted.`);
+    })
+  );
+}
+
+// src/tools/translation-memory.ts
+var import_zod15 = require("zod");
+function registerTranslationMemoryTools(server, client) {
+  server.registerTool(
+    "list_tm",
+    {
+      description: "List translation-memory entries, optionally filtered by source/target language.",
+      inputSchema: {
+        source: import_zod15.z.string().optional().describe("Source language code."),
+        target: import_zod15.z.string().optional().describe("Target language code.")
+      }
+    },
+    async (args) => run(
+      () => client.get(`/tm${buildQs(args)}`)
+    )
+  );
+  server.registerTool(
+    "upsert_tm",
+    {
+      description: "Add or update a translation-memory entry.",
+      inputSchema: {
+        sourceLang: import_zod15.z.string().min(2),
+        targetLang: import_zod15.z.string().min(2),
+        sourceText: import_zod15.z.string().min(1),
+        targetText: import_zod15.z.string().min(1),
+        context: import_zod15.z.string().optional(),
+        quality: import_zod15.z.number().min(0).max(100).optional(),
+        source: import_zod15.z.enum(["human", "mt", "imported"]).optional(),
+        provider: import_zod15.z.string().optional()
+      }
+    },
+    async (input) => run(() => client.post("/tm", input))
+  );
+  server.registerTool(
+    "lookup_tm",
+    {
+      description: "Fuzzy-match a query string against translation memory for a language pair.",
+      inputSchema: {
+        query: import_zod15.z.string().min(1),
+        sourceLang: import_zod15.z.string().min(2),
+        targetLang: import_zod15.z.string().min(2),
+        threshold: import_zod15.z.number().min(0).max(100).optional().describe("Minimum match score (default 75).")
+      }
+    },
+    async (input) => run(() => client.post("/tm/lookup", input))
+  );
+  server.registerTool(
+    "translate_text",
+    {
+      description: "Run the full translation pipeline (TM + glossary + MT provider) for a text.",
+      inputSchema: {
+        text: import_zod15.z.string().min(1),
+        from: import_zod15.z.string().min(2),
+        to: import_zod15.z.string().min(2),
+        provider: import_zod15.z.string().optional()
+      }
+    },
+    async (input) => run(() => client.post("/tm/translate", input))
+  );
+}
+
+// src/tools/users-teams.ts
+var import_zod16 = require("zod");
+function registerUsersTeamsTools(server, client) {
+  server.registerTool(
+    "list_users",
+    { description: "List users belonging to the active site.", inputSchema: {} },
+    async () => run(() => client.get("/users"))
+  );
+  server.registerTool(
+    "get_user",
+    { description: "Get a single user in the active site by id.", inputSchema: { id: import_zod16.z.string().min(1) } },
+    async ({ id }) => run(() => client.get(`/users/${id}`))
+  );
+  server.registerTool(
+    "invite_user",
+    {
+      description: "Invite a user to the site by email, optionally assigning a role. Sends an invite email.",
+      inputSchema: {
+        email: import_zod16.z.string().email(),
+        roleId: import_zod16.z.string().optional()
+      }
+    },
+    async (input) => run(() => client.post("/users/invite", input))
+  );
+  server.registerTool(
+    "update_user",
+    {
+      description: "Update a user's site membership (role and/or status).",
+      inputSchema: {
+        id: import_zod16.z.string().min(1),
+        roleId: import_zod16.z.string().nullable().optional(),
+        status: import_zod16.z.string().optional().describe("e.g. active, suspended.")
+      }
+    },
+    async ({ id, ...patch }) => run(() => client.patch(`/users/${id}`, patch))
+  );
+  server.registerTool(
+    "remove_user",
+    {
+      description: "Remove a user from the site. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: { id: import_zod16.z.string().min(1), confirm: import_zod16.z.literal(true).describe(confirmDescription) }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/users/${id}`);
+      return okText(`User "${id}" removed from the site.`);
+    })
+  );
+  server.registerTool(
+    "list_teams",
+    { description: "List teams in the active site.", inputSchema: {} },
+    async () => run(() => client.get("/teams"))
+  );
+  server.registerTool(
+    "get_team",
+    { description: "Get a single team by id.", inputSchema: { id: import_zod16.z.string().min(1) } },
+    async ({ id }) => run(() => client.get(`/teams/${id}`))
+  );
+  server.registerTool(
+    "create_team",
+    {
+      description: "Create a team.",
+      inputSchema: { name: import_zod16.z.string().min(1).max(128), description: import_zod16.z.string().nullable().optional() }
+    },
+    async (input) => run(() => client.post("/teams", input))
+  );
+  server.registerTool(
+    "update_team",
+    {
+      description: "Update a team (partial PATCH).",
+      inputSchema: {
+        id: import_zod16.z.string().min(1),
+        name: import_zod16.z.string().min(1).max(128).optional(),
+        description: import_zod16.z.string().nullable().optional()
+      }
+    },
+    async ({ id, ...patch }) => run(() => client.patch(`/teams/${id}`, patch))
+  );
+  server.registerTool(
+    "delete_team",
+    {
+      description: "Delete a team. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: { id: import_zod16.z.string().min(1), confirm: import_zod16.z.literal(true).describe(confirmDescription) }
+    },
+    async ({ id }) => run(async () => {
+      await client.delete(`/teams/${id}`);
+      return okText(`Team "${id}" deleted.`);
+    })
+  );
+  server.registerTool(
+    "list_team_members",
+    { description: "List members of a team.", inputSchema: { id: import_zod16.z.string().min(1).describe("Team id.") } },
+    async ({ id }) => run(() => client.get(`/teams/${id}/members`))
+  );
+  server.registerTool(
+    "add_team_member",
+    {
+      description: "Add a user to a team.",
+      inputSchema: { id: import_zod16.z.string().min(1).describe("Team id."), userId: import_zod16.z.string().min(1) }
+    },
+    async ({ id, userId }) => run(() => client.post(`/teams/${id}/members`, { userId }))
+  );
+  server.registerTool(
+    "remove_team_member",
+    {
+      description: "Remove a user from a team. DESTRUCTIVE \u2014 pass confirm=true.",
+      inputSchema: {
+        id: import_zod16.z.string().min(1).describe("Team id."),
+        userId: import_zod16.z.string().min(1),
+        confirm: import_zod16.z.literal(true).describe(confirmDescription)
+      }
+    },
+    async ({ id, userId }) => run(async () => {
+      await client.delete(`/teams/${id}/members/${userId}`);
+      return okText(`User "${userId}" removed from team "${id}".`);
+    })
+  );
+}
+
+// src/tools/webhooks.ts
+var import_zod17 = require("zod");
+var webhookSchema = import_zod17.z.object({
+  name: import_zod17.z.string().min(1).max(255),
+  url: import_zod17.z.string().url(),
+  actions: import_zod17.z.array(import_zod17.z.string()).optional().describe("Item events that trigger the webhook (e.g. create, update, delete)."),
+  collections: import_zod17.z.array(import_zod17.z.string()).optional().describe("Collections to filter on (empty = all)."),
+  headers: import_zod17.z.record(import_zod17.z.string()).optional(),
+  status: import_zod17.z.enum(["active", "inactive"]).optional(),
+  secret: import_zod17.z.string().nullable().optional()
+});
+function registerWebhookTools(server, client) {
+  registerCrud(server, client, {
+    basePath: "/webhooks",
+    resource: "webhook",
+    namePrefix: "webhook",
+    createSchema: webhookSchema.shape,
+    updateSchema: webhookSchema.partial().shape,
+    // The webhooks route has no GET /:id; list returns full rows.
+    enableGet: false
+  });
+}
+
+// src/tools/index.ts
+function registerAllTools(server, client) {
+  registerCollectionTools(server, client);
+  registerFieldTools(server, client);
+  registerItemTools(server, client);
+  registerRelationTools(server, client);
+  registerContentConfigTools(server, client);
+  registerSearchMediaTools(server, client);
+  registerTranslationMemoryTools(server, client);
+  registerPermissionTools(server, client);
+  registerAccessTools(server, client);
+  registerApiKeyTools(server, client);
+  registerUsersTeamsTools(server, client);
+  registerWebhookTools(server, client);
+  registerAgentTools(server, client);
+  registerOpsTools(server, client);
+  registerAdminTools(server, client);
+  registerExtensionTools(server, client);
+}
+
+// src/index.ts
+async function main() {
+  const config = configFromEnv();
+  const client = new LumiBaseClient(config);
+  const server = new import_mcp.McpServer({
+    name: "lumibase",
+    version: "0.9.0"
+  });
+  registerAllTools(server, client);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("[lumibase-mcp] Fatal:", err);
+  process.exit(1);
+});