@centrali-io/centrali-mcp 4.2.0 → 4.2.2

package/README.md

@@ -2,7 +2,7 @@
 
 MCP (Model Context Protocol) server for the Centrali platform. Lets AI assistants (Claude, Cursor, etc.) interact with Centrali workspaces — query data, manage records, search, trigger compute functions, and more.
 
-Built on `@centrali-io/centrali-sdk` v3.1.0. Authenticates via service account client credentials.
+Built on `@centrali-io/centrali-sdk` v4.2.0. Authenticates via service account client credentials.
 
 ## Setup
 
@@ -33,6 +33,7 @@ Add to your MCP client configuration (e.g., Claude Desktop, Cursor):
 | `CENTRALI_CLIENT_ID` | Yes | Service account client ID |
 | `CENTRALI_CLIENT_SECRET` | Yes | Service account client secret |
 | `CENTRALI_WORKSPACE` | Yes | Workspace slug to operate in |
+| `CENTRALI_PAGES_URL` | No | Override pages API URL (default: derived as `api.{domain}/pages`) |
 
 ## Available Tools
 
@@ -75,6 +76,29 @@ Add to your MCP client configuration (e.g., Claude Desktop, Cursor):
 | `list_smart_queries` | List smart queries, optionally filtered by structure |
 | `execute_smart_query` | Execute a smart query with optional variables |
 
+### Pages
+| Tool | Description |
+|------|-------------|
+| `list_pages` | List all pages in the workspace |
+| `get_page` | Get a page by ID |
+| `create_page` | Create a new page (list, detail, form, or dashboard) |
+| `update_page` | Update page metadata (name, slug, description) |
+| `delete_page` | Soft-delete a page |
+| `save_page_draft` | Save or update a page's draft definition |
+| `get_page_draft` | Get the current draft of a page |
+| `list_page_versions` | List all versions of a page |
+| `validate_page` | Validate a page draft before publishing |
+| `publish_page` | Publish a page to its runtime URL |
+| `unpublish_page` | Unpublish a page |
+| `set_page_access_policy` | Set access policy (public, authenticated, role-gated) |
+| `get_page_theme` | Get workspace page theme |
+| `set_page_theme` | Set workspace page theme (colors, logo, font) |
+| `get_navigation` | Get workspace navigation config |
+| `set_navigation` | Set workspace navigation config |
+| `delete_navigation` | Delete navigation config (revert to standalone pages) |
+| `generate_starter_pages` | Generate page proposals from structure IDs |
+| `accept_page_proposal` | Accept a generated proposal and create the page |
+
 ## Resources
 
 | URI | Description |

package/dist/index.js

@@ -21,6 +21,8 @@ const smart_queries_js_1 = require("./tools/smart-queries.js");
 const orchestrations_js_1 = require("./tools/orchestrations.js");
 const insights_js_1 = require("./tools/insights.js");
 const validation_js_1 = require("./tools/validation.js");
+const pages_js_1 = require("./tools/pages.js");
+const describe_js_1 = require("./tools/describe.js");
 const structures_js_2 = require("./resources/structures.js");
 function getRequiredEnv(name) {
     const value = process.env[name];
@@ -56,6 +58,8 @@ function main() {
         (0, orchestrations_js_1.registerOrchestrationTools)(server, sdk);
         (0, insights_js_1.registerInsightTools)(server, sdk);
         (0, validation_js_1.registerValidationTools)(server, sdk);
+        (0, pages_js_1.registerPageTools)(server, sdk, baseUrl, workspaceId);
+        (0, describe_js_1.registerDescribeTools)(server);
         // Register resources
         (0, structures_js_2.registerCollectionResources)(server, sdk);
         (0, structures_js_2.registerStructureResources)(server, sdk);

package/dist/tools/compute.js

@@ -129,4 +129,327 @@ function registerComputeTools(server, sdk) {
             };
         }
     }));
+    // ── Function CRUD tools ──────────────────────────────────────────
+    server.tool("get_function", "Get a compute function by ID. Returns the full function definition including code.", {
+        functionId: zod_1.z.string().describe("The compute function ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ functionId }) {
+        try {
+            const result = yield sdk.functions.get(functionId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting function '${functionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_function", "Create a new compute function. Compute functions are JavaScript code blocks that run server-side.", {
+        name: zod_1.z.string().describe("Display name for the function"),
+        slug: zod_1.z.string().describe("URL-safe unique identifier (e.g., 'process-order')"),
+        code: zod_1.z.string().describe("JavaScript source code. Must export an async function: module.exports = async (ctx) => { ... }"),
+        description: zod_1.z.string().optional().describe("Optional description of what the function does"),
+        timeout: zod_1.z.number().optional().describe("Execution timeout in milliseconds (default: 30000)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, code, description, timeout }) {
+        try {
+            const input = { name, slug, code };
+            if (description !== undefined)
+                input.description = description;
+            if (timeout !== undefined)
+                input.timeout = timeout;
+            const result = yield sdk.functions.create(input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating function '${slug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_function", "Update an existing compute function by ID. Only include the fields you want to change.", {
+        functionId: zod_1.z.string().describe("The compute function ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        code: zod_1.z.string().optional().describe("Updated JavaScript source code"),
+        timeout: zod_1.z.number().optional().describe("Updated execution timeout in milliseconds"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ functionId, name, description, code, timeout }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (code !== undefined)
+                input.code = code;
+            if (timeout !== undefined)
+                input.timeout = timeout;
+            const result = yield sdk.functions.update(functionId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating function '${functionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_function", "Delete a compute function by ID.", {
+        functionId: zod_1.z.string().describe("The compute function ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ functionId }) {
+        try {
+            yield sdk.functions.delete(functionId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Function '${functionId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting function '${functionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("test_function", "Test execute code without saving it as a function. Useful for validating function code before creating or updating.", {
+        code: zod_1.z.string().describe("JavaScript code to test. Must export an async function: module.exports = async (ctx) => { ... }"),
+        input: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Optional input data passed to the function as ctx.input"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ code, input }) {
+        try {
+            const testInput = { code };
+            if (input !== undefined)
+                testInput.input = input;
+            const result = yield sdk.functions.testExecute(testInput);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, "test-executing function"),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    // ── Trigger CRUD tools ───────────────────────────────────────────
+    server.tool("get_trigger", "Get a function trigger by ID. Returns full trigger details including execution type and metadata.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId }) {
+        try {
+            const result = yield sdk.triggers.getDetails(triggerId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting trigger '${triggerId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_trigger", "Create a new function trigger. Triggers define how and when a compute function is executed.", {
+        name: zod_1.z.string().describe("Display name for the trigger"),
+        functionId: zod_1.z.string().describe("The compute function ID (UUID) to execute"),
+        executionType: zod_1.z
+            .enum(["on-demand", "event-driven", "scheduled", "webhook"])
+            .describe("How the trigger fires: on-demand (manual), event-driven (data events), scheduled (cron), or webhook (HTTP)"),
+        description: zod_1.z.string().optional().describe("Optional description"),
+        triggerMetadata: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Type-specific configuration. For event-driven: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For webhook: auto-generated URL."),
+        enabled: zod_1.z.boolean().optional().describe("Whether the trigger is enabled (default: true)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, functionId, executionType, description, triggerMetadata, enabled }) {
+        try {
+            const input = { name, functionId, executionType };
+            if (description !== undefined)
+                input.description = description;
+            if (triggerMetadata !== undefined)
+                input.triggerMetadata = triggerMetadata;
+            if (enabled !== undefined)
+                input.enabled = enabled;
+            const result = yield sdk.triggers.create(input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating trigger '${name}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_trigger", "Update an existing function trigger by ID. Only include the fields you want to change.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        enabled: zod_1.z.boolean().optional().describe("Enable or disable the trigger"),
+        triggerMetadata: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Updated type-specific configuration"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId, name, description, enabled, triggerMetadata }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (enabled !== undefined)
+                input.enabled = enabled;
+            if (triggerMetadata !== undefined)
+                input.triggerMetadata = triggerMetadata;
+            const result = yield sdk.triggers.update(triggerId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating trigger '${triggerId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_trigger", "Delete a function trigger by ID.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId }) {
+        try {
+            yield sdk.triggers.delete(triggerId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Trigger '${triggerId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting trigger '${triggerId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("pause_trigger", "Pause a function trigger. Paused triggers will not fire until resumed.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID) to pause"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId }) {
+        try {
+            const result = yield sdk.triggers.pauseTrigger(triggerId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `pausing trigger '${triggerId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("resume_trigger", "Resume a paused function trigger. The trigger will start firing again on matching events or schedules.", {
+        triggerId: zod_1.z.string().describe("The trigger ID (UUID) to resume"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ triggerId }) {
+        try {
+            const result = yield sdk.triggers.resumeTrigger(triggerId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `resuming trigger '${triggerId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/describe.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Introspection tools that teach AI assistants the valid shapes, schemas,
+ * and domain concepts for every Centrali API. These tools return static
+ * documentation — no network calls, no auth required.
+ *
+ * Pattern inspired by Supabase MCP (list_tables / get_schemas) and
+ * Stripe MCP (search_stripe_documentation).
+ */
+export declare function registerDescribeTools(server: McpServer): void;