@centrali-io/centrali-mcp 4.2.1 → 4.2.2

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,
+        };
+      }
+    }
+  );
 }

package/src/tools/describe.ts

@@ -32,6 +32,9 @@ export function registerDescribeTools(server: McpServer) {
                   tools: [
                     "list_collections",
                     "get_collection",
+                    "create_collection",
+                    "update_collection",
+                    "delete_collection",
                     "list_structures (deprecated)",
                     "get_structure (deprecated)",
                   ],
@@ -61,13 +64,36 @@ export function registerDescribeTools(server: McpServer) {
                   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:
@@ -76,6 +102,11 @@ export function registerDescribeTools(server: McpServer) {
                   tools: [
                     "list_orchestrations",
                     "get_orchestration",
+                    "create_orchestration",
+                    "update_orchestration",
+                    "delete_orchestration",
+                    "activate_orchestration",
+                    "pause_orchestration",
                     "trigger_orchestration",
                     "list_orchestration_runs",
                     "get_orchestration_run",
@@ -197,11 +228,30 @@ export function registerDescribeTools(server: McpServer) {
                 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,
@@ -418,12 +468,72 @@ export function registerDescribeTools(server: McpServer) {
                 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,
@@ -474,11 +584,43 @@ export function registerDescribeTools(server: McpServer) {
                 },
                 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,
@@ -541,8 +683,42 @@ export function registerDescribeTools(server: McpServer) {
                 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",