@centrali-io/centrali-mcp 4.2.0 → 4.2.2

package/dist/tools/smart-queries.js

@@ -93,4 +93,156 @@ function registerSmartQueryTools(server, sdk) {
             };
         }
     }));
+    server.tool("get_smart_query", "Get a smart query by ID. Returns the full query definition including filters, sort, and variable declarations.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID)"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId }) {
+        try {
+            const result = yield sdk.smartQueries.get(recordSlug, queryId);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `getting smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("create_smart_query", "Create a new smart query for a collection. Smart queries are reusable, parameterized queries with filter, sort, and variable support.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug to create the query for"),
+        name: zod_1.z.string().describe("Display name for the smart query"),
+        description: zod_1.z.string().optional().describe("Optional description"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The query definition object with where, sort, limit, select, join, etc."),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, name, description, queryDefinition }) {
+        try {
+            const input = { name, queryDefinition };
+            if (description !== undefined)
+                input.description = description;
+            const result = yield sdk.smartQueries.create(recordSlug, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating smart query '${name}' for '${recordSlug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_smart_query", "Update an existing smart query. Only include the fields you want to change.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .optional()
+            .describe("Updated query definition object"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId, name, description, queryDefinition }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (queryDefinition !== undefined)
+                input.queryDefinition = queryDefinition;
+            const result = yield sdk.smartQueries.update(recordSlug, queryId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_smart_query", "Delete a smart query by ID.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug the query belongs to"),
+        queryId: zod_1.z.string().describe("The smart query ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryId }) {
+        try {
+            yield sdk.smartQueries.delete(recordSlug, queryId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Smart query '${queryId}' deleted from '${recordSlug}'.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting smart query '${queryId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("test_smart_query", "Test execute a query definition without saving it. Useful for validating query syntax and previewing results before creating a smart query.", {
+        recordSlug: zod_1.z.string().describe("The structure's record slug to test against"),
+        queryDefinition: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.any())
+            .describe("The query definition to test (where, sort, limit, select, etc.)"),
+        variables: zod_1.z
+            .record(zod_1.z.string(), zod_1.z.string())
+            .optional()
+            .describe("Optional variables to substitute in the query"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ recordSlug, queryDefinition, variables }) {
+        try {
+            const input = { queryDefinition };
+            if (variables !== undefined)
+                input.variables = variables;
+            const result = yield sdk.smartQueries.test(recordSlug, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `test-executing smart query for '${recordSlug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/dist/tools/structures.js

@@ -135,4 +135,121 @@ function registerCollectionTools(server, sdk) {
             };
         }
     }));
+    server.tool("create_collection", "Create a new data collection (schema). Define the name, slug, description, and properties (fields) for the collection.", {
+        name: zod_1.z.string().describe("Display name for the collection (e.g., 'Customers')"),
+        slug: zod_1.z.string().describe("URL-safe identifier used in API calls (e.g., 'customers')"),
+        description: zod_1.z.string().optional().describe("Optional description of the collection"),
+        properties: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Array of property definitions. Each property has name, type, and optional config (required, unique, defaultValue, description, config)"),
+        enableVersioning: zod_1.z.boolean().optional().describe("Enable record versioning (default: false)"),
+        schemaDiscoveryMode: zod_1.z
+            .enum(["strict", "flexible"])
+            .optional()
+            .describe("Schema discovery mode: 'strict' rejects unknown fields, 'flexible' auto-adds them"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Optional tags for organizing collections"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ name, slug, description, properties, enableVersioning, schemaDiscoveryMode, tags }) {
+        try {
+            const input = { name, slug };
+            if (description !== undefined)
+                input.description = description;
+            if (properties !== undefined)
+                input.properties = properties;
+            if (enableVersioning !== undefined)
+                input.enableVersioning = enableVersioning;
+            if (schemaDiscoveryMode !== undefined)
+                input.schemaDiscoveryMode = schemaDiscoveryMode;
+            if (tags !== undefined)
+                input.tags = tags;
+            const result = yield sdk.collections.create(input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `creating collection '${slug}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("update_collection", "Update an existing collection by ID. Only include the fields you want to change.", {
+        collectionId: zod_1.z.string().describe("The collection ID (UUID) to update"),
+        name: zod_1.z.string().optional().describe("Updated display name"),
+        description: zod_1.z.string().optional().describe("Updated description"),
+        properties: zod_1.z
+            .array(zod_1.z.record(zod_1.z.string(), zod_1.z.any()))
+            .optional()
+            .describe("Updated array of property definitions (replaces existing properties)"),
+        enableVersioning: zod_1.z.boolean().optional().describe("Enable or disable record versioning"),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Updated tags"),
+        defaultTtlSeconds: zod_1.z.number().nullable().optional().describe("Default TTL in seconds for new records. Set to null to clear."),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ collectionId, name, description, properties, enableVersioning, tags, defaultTtlSeconds }) {
+        try {
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (description !== undefined)
+                input.description = description;
+            if (properties !== undefined)
+                input.properties = properties;
+            if (enableVersioning !== undefined)
+                input.enableVersioning = enableVersioning;
+            if (tags !== undefined)
+                input.tags = tags;
+            if (defaultTtlSeconds !== undefined)
+                input.defaultTtlSeconds = defaultTtlSeconds;
+            const result = yield sdk.collections.update(collectionId, input);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `updating collection '${collectionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
+    server.tool("delete_collection", "Delete a collection by ID. This permanently removes the collection schema and all its records.", {
+        collectionId: zod_1.z.string().describe("The collection ID (UUID) to delete"),
+    }, (_a) => __awaiter(this, [_a], void 0, function* ({ collectionId }) {
+        try {
+            yield sdk.collections.delete(collectionId);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Collection '${collectionId}' deleted successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatError(error, `deleting collection '${collectionId}'`),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centrali-io/centrali-mcp",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Centrali MCP Server - AI assistant integration for Centrali workspaces",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -25,7 +25,7 @@
   "author": "Blueinit",
   "license": "ISC",
   "dependencies": {
-    "@centrali-io/centrali-sdk": "^4.0.1",
+    "@centrali-io/centrali-sdk": "^4.2.0",
     "@modelcontextprotocol/sdk": "^1.12.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -11,6 +11,8 @@ import { registerSmartQueryTools } from "./tools/smart-queries.js";
 import { registerOrchestrationTools } from "./tools/orchestrations.js";
 import { registerInsightTools } from "./tools/insights.js";
 import { registerValidationTools } from "./tools/validation.js";
+import { registerPageTools } from "./tools/pages.js";
+import { registerDescribeTools } from "./tools/describe.js";
 import { registerStructureResources, registerCollectionResources } from "./resources/structures.js";
 
 function getRequiredEnv(name: string): string {
@@ -50,6 +52,8 @@ async function main() {
   registerOrchestrationTools(server, sdk);
   registerInsightTools(server, sdk);
   registerValidationTools(server, sdk);
+  registerPageTools(server, sdk, baseUrl, workspaceId);
+  registerDescribeTools(server);
 
   // Register resources
   registerCollectionResources(server, sdk);

package/src/tools/compute.ts

@@ -138,4 +138,375 @@ export function registerComputeTools(server: McpServer, sdk: CentraliSDK) {
       }
     }
   );
+
+  // ── Function CRUD tools ──────────────────────────────────────────
+
+  server.tool(
+    "get_function",
+    "Get a compute function by ID. Returns the full function definition including code.",
+    {
+      functionId: z.string().describe("The compute function ID (UUID)"),
+    },
+    async ({ functionId }) => {
+      try {
+        const result = await sdk.functions.get(functionId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("Display name for the function"),
+      slug: z.string().describe("URL-safe unique identifier (e.g., 'process-order')"),
+      code: z.string().describe("JavaScript source code. Must export an async function: module.exports = async (ctx) => { ... }"),
+      description: z.string().optional().describe("Optional description of what the function does"),
+      timeout: z.number().optional().describe("Execution timeout in milliseconds (default: 30000)"),
+    },
+    async ({ name, slug, code, description, timeout }) => {
+      try {
+        const input: Record<string, any> = { name, slug, code };
+        if (description !== undefined) input.description = description;
+        if (timeout !== undefined) input.timeout = timeout;
+
+        const result = await sdk.functions.create(input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The compute function ID (UUID) to update"),
+      name: z.string().optional().describe("Updated display name"),
+      description: z.string().optional().describe("Updated description"),
+      code: z.string().optional().describe("Updated JavaScript source code"),
+      timeout: z.number().optional().describe("Updated execution timeout in milliseconds"),
+    },
+    async ({ functionId, name, description, code, timeout }) => {
+      try {
+        const input: Record<string, any> = {};
+        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 = await sdk.functions.update(functionId, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating function '${functionId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_function",
+    "Delete a compute function by ID.",
+    {
+      functionId: z.string().describe("The compute function ID (UUID) to delete"),
+    },
+    async ({ functionId }) => {
+      try {
+        await sdk.functions.delete(functionId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Function '${functionId}' deleted successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("JavaScript code to test. Must export an async function: module.exports = async (ctx) => { ... }"),
+      input: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Optional input data passed to the function as ctx.input"),
+    },
+    async ({ code, input }) => {
+      try {
+        const testInput: Record<string, any> = { code };
+        if (input !== undefined) testInput.input = input;
+
+        const result = await sdk.functions.testExecute(testInput as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The trigger ID (UUID)"),
+    },
+    async ({ triggerId }) => {
+      try {
+        const result = await sdk.triggers.getDetails(triggerId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("Display name for the trigger"),
+      functionId: z.string().describe("The compute function ID (UUID) to execute"),
+      executionType: 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: z.string().optional().describe("Optional description"),
+      triggerMetadata: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Type-specific configuration. For event-driven: { event, recordSlug }. For scheduled: { scheduleType, cronExpression, timezone }. For webhook: auto-generated URL."),
+      enabled: z.boolean().optional().describe("Whether the trigger is enabled (default: true)"),
+    },
+    async ({ name, functionId, executionType, description, triggerMetadata, enabled }) => {
+      try {
+        const input: Record<string, any> = { name, functionId, executionType };
+        if (description !== undefined) input.description = description;
+        if (triggerMetadata !== undefined) input.triggerMetadata = triggerMetadata;
+        if (enabled !== undefined) input.enabled = enabled;
+
+        const result = await sdk.triggers.create(input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The trigger ID (UUID) to update"),
+      name: z.string().optional().describe("Updated display name"),
+      description: z.string().optional().describe("Updated description"),
+      enabled: z.boolean().optional().describe("Enable or disable the trigger"),
+      triggerMetadata: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Updated type-specific configuration"),
+    },
+    async ({ triggerId, name, description, enabled, triggerMetadata }) => {
+      try {
+        const input: Record<string, any> = {};
+        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 = await sdk.triggers.update(triggerId, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating trigger '${triggerId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_trigger",
+    "Delete a function trigger by ID.",
+    {
+      triggerId: z.string().describe("The trigger ID (UUID) to delete"),
+    },
+    async ({ triggerId }) => {
+      try {
+        await sdk.triggers.delete(triggerId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Trigger '${triggerId}' deleted successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The trigger ID (UUID) to pause"),
+    },
+    async ({ triggerId }) => {
+      try {
+        const result = await sdk.triggers.pauseTrigger(triggerId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        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: z.string().describe("The trigger ID (UUID) to resume"),
+    },
+    async ({ triggerId }) => {
+      try {
+        const result = await sdk.triggers.resumeTrigger(triggerId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `resuming trigger '${triggerId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }