@centrali-io/centrali-mcp 4.2.1 → 4.2.2

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.js

@@ -35,6 +35,9 @@ function registerDescribeTools(server) {
                                 tools: [
                                     "list_collections",
                                     "get_collection",
+                                    "create_collection",
+                                    "update_collection",
+                                    "delete_collection",
                                     "list_structures (deprecated)",
                                     "get_structure (deprecated)",
                                 ],
@@ -61,12 +64,35 @@ function registerDescribeTools(server) {
                             compute: {
                                 summary: "Server-side JavaScript functions with triggers (on-demand, event-driven, scheduled, webhook).",
                                 describeWith: "describe_compute",
-                                tools: ["list_functions", "list_triggers", "invoke_trigger"],
+                                tools: [
+                                    "list_functions",
+                                    "get_function",
+                                    "create_function",
+                                    "update_function",
+                                    "delete_function",
+                                    "test_function",
+                                    "list_triggers",
+                                    "get_trigger",
+                                    "create_trigger",
+                                    "update_trigger",
+                                    "delete_trigger",
+                                    "invoke_trigger",
+                                    "pause_trigger",
+                                    "resume_trigger",
+                                ],
                             },
                             smart_queries: {
                                 summary: "Reusable, parameterized queries defined in the console. Support {{variable}} substitution.",
                                 describeWith: "describe_smart_queries",
-                                tools: ["list_smart_queries", "execute_smart_query"],
+                                tools: [
+                                    "list_smart_queries",
+                                    "get_smart_query",
+                                    "create_smart_query",
+                                    "update_smart_query",
+                                    "delete_smart_query",
+                                    "execute_smart_query",
+                                    "test_smart_query",
+                                ],
                             },
                             orchestrations: {
                                 summary: "Multi-step workflows that chain compute functions. Support sequential execution with input/output passing between steps.",
@@ -74,6 +100,11 @@ function registerDescribeTools(server) {
                                 tools: [
                                     "list_orchestrations",
                                     "get_orchestration",
+                                    "create_orchestration",
+                                    "update_orchestration",
+                                    "delete_orchestration",
+                                    "activate_orchestration",
+                                    "pause_orchestration",
                                     "trigger_orchestration",
                                     "list_orchestration_runs",
                                     "get_orchestration_run",
@@ -176,11 +207,30 @@ function registerDescribeTools(server) {
                             json: "Arbitrary JSON object",
                             auto_increment: "Auto-incrementing integer (read-only)",
                         },
+                        crud_tools: {
+                            create_collection: {
+                                description: "Create a new collection with name, slug, properties, and optional settings",
+                                required_params: ["name", "slug"],
+                                optional_params: ["description", "properties", "enableVersioning", "schemaDiscoveryMode", "tags"],
+                            },
+                            update_collection: {
+                                description: "Update an existing collection by ID. Partial updates supported.",
+                                required_params: ["collectionId"],
+                                optional_params: ["name", "description", "properties", "enableVersioning", "tags", "defaultTtlSeconds"],
+                            },
+                            delete_collection: {
+                                description: "Delete a collection by ID. Permanently removes the schema and all records.",
+                                required_params: ["collectionId"],
+                            },
+                        },
                         tips: [
                             "Use list_collections to see all collections in the workspace",
                             "Use get_collection with a recordSlug to see the full property definitions",
                             "The recordSlug is what you use in query_records, create_record, etc.",
                             "Reference fields create relationships between collections — use 'expand' parameter in queries to join them",
+                            "Use create_collection to define new data schemas with typed properties",
+                            "Properties array defines the fields — each needs at minimum a name and type",
+                            "Use schemaDiscoveryMode: 'flexible' to auto-add new fields when records are created",
                         ],
                     }, null, 2),
                 },
@@ -355,12 +405,72 @@ function registerDescribeTools(server) {
                             status: "'active' | 'paused'",
                             config: "object — type-specific configuration (cron, event filters, etc.)",
                         },
+                        function_crud: {
+                            get_function: {
+                                description: "Get a compute function by ID, including its code",
+                                required_params: ["functionId"],
+                            },
+                            create_function: {
+                                description: "Create a new compute function",
+                                required_params: ["name", "slug", "code"],
+                                optional_params: ["description", "timeout"],
+                                code_format: "module.exports = async (ctx) => { /* your code */ return result; }",
+                            },
+                            update_function: {
+                                description: "Update an existing function. Partial updates supported.",
+                                required_params: ["functionId"],
+                                optional_params: ["name", "description", "code", "timeout"],
+                            },
+                            delete_function: {
+                                description: "Delete a compute function by ID",
+                                required_params: ["functionId"],
+                            },
+                            test_function: {
+                                description: "Test execute code without saving. Returns output, duration, and logs.",
+                                required_params: ["code"],
+                                optional_params: ["input"],
+                            },
+                        },
+                        trigger_crud: {
+                            get_trigger: {
+                                description: "Get any trigger by ID (all execution types)",
+                                required_params: ["triggerId"],
+                            },
+                            create_trigger: {
+                                description: "Create a new function trigger",
+                                required_params: ["name", "functionId", "executionType"],
+                                optional_params: ["description", "triggerMetadata", "enabled"],
+                                triggerMetadata_examples: {
+                                    "event-driven": { event: "record.created", recordSlug: "orders" },
+                                    scheduled: { scheduleType: "cron", cronExpression: "0 9 * * *", timezone: "America/New_York" },
+                                },
+                            },
+                            update_trigger: {
+                                description: "Update an existing trigger. Partial updates supported.",
+                                required_params: ["triggerId"],
+                                optional_params: ["name", "description", "enabled", "triggerMetadata"],
+                            },
+                            delete_trigger: {
+                                description: "Delete a trigger by ID",
+                                required_params: ["triggerId"],
+                            },
+                            pause_trigger: {
+                                description: "Pause a trigger to temporarily disable it",
+                                required_params: ["triggerId"],
+                            },
+                            resume_trigger: {
+                                description: "Resume a paused trigger",
+                                required_params: ["triggerId"],
+                            },
+                        },
                         tips: [
                             "Use list_functions to see all available functions",
                             "Use list_triggers to see how functions are wired to execution events",
                             "Only on-demand triggers can be invoked via invoke_trigger — other types fire automatically",
                             "Functions receive the trigger payload in their execution context",
-                            "Triggers can be paused (status: 'paused') without deleting them",
+                            "Use pause_trigger/resume_trigger to temporarily disable triggers without deleting them",
+                            "Use test_function to validate code before creating or updating a function",
+                            "Use create_function + create_trigger together to set up a complete compute pipeline",
                         ],
                     }, null, 2),
                 },
@@ -398,11 +508,43 @@ function registerDescribeTools(server) {
                             },
                             note: "Variable values are always passed as strings — the query engine handles type coercion",
                         },
+                        crud_tools: {
+                            get_smart_query: {
+                                description: "Get a smart query by ID, including its full definition",
+                                required_params: ["recordSlug", "queryId"],
+                            },
+                            create_smart_query: {
+                                description: "Create a new smart query for a collection",
+                                required_params: ["recordSlug", "name", "queryDefinition"],
+                                optional_params: ["description"],
+                                queryDefinition_example: {
+                                    where: { status: { "$eq": "active" } },
+                                    sort: [{ field: "createdAt", direction: "desc" }],
+                                    limit: 100,
+                                },
+                            },
+                            update_smart_query: {
+                                description: "Update an existing smart query. Partial updates supported.",
+                                required_params: ["recordSlug", "queryId"],
+                                optional_params: ["name", "description", "queryDefinition"],
+                            },
+                            delete_smart_query: {
+                                description: "Delete a smart query by ID",
+                                required_params: ["recordSlug", "queryId"],
+                            },
+                            test_smart_query: {
+                                description: "Test execute a query definition without saving it. Preview results before creating.",
+                                required_params: ["recordSlug", "queryDefinition"],
+                                optional_params: ["variables"],
+                            },
+                        },
                         tips: [
                             "Use list_smart_queries to discover available queries (optionally filter by collection slug)",
                             "Smart queries return the same result shape as query_records",
                             "Variables are defined when creating the query in the console — check the query's variables array to see what's expected",
                             "Prefer smart queries over ad-hoc query_records filters for complex/reusable logic",
+                            "Use test_smart_query to validate query syntax and preview results before saving",
+                            "Use create_smart_query to save reusable queries that can be executed with execute_smart_query",
                         ],
                     }, null, 2),
                 },
@@ -453,8 +595,42 @@ function registerDescribeTools(server) {
                             startedAt: "ISO 8601 datetime | null",
                             completedAt: "ISO 8601 datetime | null",
                         },
+                        crud_tools: {
+                            create_orchestration: {
+                                description: "Create a new orchestration workflow",
+                                required_params: ["slug", "name", "trigger", "steps"],
+                                optional_params: ["description"],
+                                trigger_example: { type: "on-demand" },
+                                step_example: {
+                                    id: "validate",
+                                    type: "compute",
+                                    functionId: "func-uuid",
+                                    onSuccess: { nextStepId: "process" },
+                                },
+                            },
+                            update_orchestration: {
+                                description: "Update an existing orchestration. Partial updates supported.",
+                                required_params: ["orchestrationId"],
+                                optional_params: ["name", "description", "status", "trigger", "steps"],
+                            },
+                            delete_orchestration: {
+                                description: "Delete an orchestration and all its runs",
+                                required_params: ["orchestrationId"],
+                            },
+                            activate_orchestration: {
+                                description: "Set orchestration status to 'active' so it can be triggered",
+                                required_params: ["orchestrationId"],
+                            },
+                            pause_orchestration: {
+                                description: "Set orchestration status to 'paused' to prevent triggering",
+                                required_params: ["orchestrationId"],
+                            },
+                        },
                         tips: [
                             "Use list_orchestrations to see available workflows",
+                            "Use create_orchestration to define new multi-step workflows",
+                            "Use activate_orchestration to enable a draft orchestration for triggering",
+                            "Use pause_orchestration to temporarily disable an orchestration without deleting it",
                             "Use trigger_orchestration with an input object to start a run",
                             "Use get_orchestration_run with includeSteps=true to see step-by-step execution details",
                             "Orchestrations must be 'active' to be triggered — draft orchestrations cannot run",