@centrali-io/centrali-mcp 4.2.1 → 4.2.3

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