meebly-onboarding-mcp-server 0.0.1

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "meebly-onboarding-mcp-server",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^4.2.1",
+    "zod-to-json-schema": "^3.25.1"
+  }
+}

package/src/helpers/httpClient.ts

@@ -0,0 +1,17 @@
+import axios from 'axios';
+
+// For development, it can read from env var to point to local server
+// In production, it will point to the deployed Meebly Backend because the env var will be undefined
+const baseUrl =
+  (process.env.MEEBLY_BACKEND_URL || 'https://api.meebly.ai') + '/v1';
+
+// Client will set
+const apiKey = process.env.MEEBLY_API_KEY || '';
+
+export const httpClient = axios.create({
+  baseURL: baseUrl,
+  validateStatus: () => true, // never throw when not 2XX
+  headers: {
+    'X-API-Key': apiKey,
+  },
+});

package/src/helpers/toolHelper.ts

@@ -0,0 +1,40 @@
+import { AxiosResponse } from 'axios';
+
+/**
+ *  Helper function to maintain consistent tool return structure for success, failure, and error cases.
+ */
+export function toolSuccess(
+  response: AxiosResponse,
+  structuredContent?: Record<string, unknown>
+) {
+  return toolReturn(
+    `Operation performed successfully.\n${JSON.stringify(response.data, null, 2)}`,
+    structuredContent
+  );
+}
+
+export function toolFailure(response: AxiosResponse) {
+  return toolReturn(
+    `Operation failed. Status: ${response.status}\nResponse: ${JSON.stringify(response.data, null, 2)}`
+  );
+}
+
+export function toolError(error: unknown) {
+  return toolReturn(`Error occurred while performing operation: ${error}`);
+}
+
+// Helper function to format tool return messages in proper structure
+function toolReturn(
+  message: string,
+  structuredContent?: Record<string, unknown>
+) {
+  return {
+    content: [
+      {
+        type: 'text' as const,
+        text: message,
+      },
+    ],
+    structuredContent: structuredContent,
+  };
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+// Import all tools and resources
+import * as tools from './tools/index.js';
+import * as resources from './resources/index.js';
+
+// Create the MCP server instance
+const server: McpServer = new McpServer({
+  name: 'meebly-onboarding-mcp-server',
+  version: '0.0.1',
+});
+
+// Register the tools
+Object.values(tools).forEach((tool) => {
+  server.registerTool(
+    tool.name,
+    {
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      outputSchema: tool.outputSchema,
+    },
+    tool.handler
+  );
+});
+
+// Register the resources
+Object.values(resources).forEach((resource) => {
+  server.registerResource(
+    resource.name,
+    resource.uri,
+    resource.metadata,
+    resource.read
+  );
+});
+
+// Start listening over stdio
+const transport = new StdioServerTransport();
+await server.connect(transport);
+
+// Keep process alive
+process.stdin.resume();

package/src/resources/createActionEndpoint.ts

@@ -0,0 +1,51 @@
+import { V1ActionDataSchema } from '../../../src/utils/validation.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+const actionJsonSchema = zodToJsonSchema(
+  V1ActionDataSchema as any,
+  'V1ActionDataSchema'
+);
+const responseSchema = {
+  type: 'object',
+  properties: {
+    status: {
+      type: 'string',
+      description: 'Result status',
+    },
+    agent: actionJsonSchema,
+  },
+  required: ['status', 'agent'],
+};
+
+/**
+ * Resource describing the createAgent POST endpoint
+ */
+export const createActionEndpointResource = {
+  name: 'createActionEndpoint',
+  uri: 'api://meebly/action/create',
+  metadata: {
+    description:
+      'Describes the POST /action endpoint used to create new actions',
+    title: 'Create Action Endpoint',
+  },
+  read: async () => {
+    return {
+      contents: [
+        {
+          uri: 'api://meebly/action/create',
+          text: `
+POST /action
+
+Creates a new action.
+
+Request body schema (JSON Schema):
+${JSON.stringify(actionJsonSchema, null, 2)}
+
+Response schema (JSON Schema):
+${JSON.stringify(responseSchema, null, 2)}
+          `.trim(),
+        },
+      ],
+    };
+  },
+} as const;

package/src/resources/createAgentEndpoint.ts

@@ -0,0 +1,50 @@
+import { AgentDataSchema } from '../../../src/utils/validation.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+const agentJsonSchema = zodToJsonSchema(
+  AgentDataSchema as any,
+  'AgentDataSchema'
+);
+const responseSchema = {
+  type: 'object',
+  properties: {
+    status: {
+      type: 'string',
+      description: 'Result status',
+    },
+    agent: agentJsonSchema,
+  },
+  required: ['status', 'agent'],
+};
+
+/**
+ * Resource describing the createAgent POST endpoint
+ */
+export const createAgentEndpointResource = {
+  name: 'createAgentEndpoint',
+  uri: 'api://meebly/agent/create',
+  metadata: {
+    description: 'Describes the POST /agent endpoint used to create new agents',
+    title: 'Create Agent Endpoint',
+  },
+  read: async () => {
+    return {
+      contents: [
+        {
+          uri: 'api://meebly/agent/create',
+          text: `
+POST /agent
+
+Creates a new agent.
+
+Request body schema (JSON Schema):
+${JSON.stringify(agentJsonSchema, null, 2)}
+
+Response schema (JSON Schema):
+${JSON.stringify(responseSchema, null, 2)}
+          `.trim(),
+        },
+      ],
+    };
+  },
+} as const;

package/src/resources/index.ts

@@ -0,0 +1,3 @@
+export { createActionEndpointResource } from './createActionEndpoint.js';
+export { createAgentEndpointResource } from './createAgentEndpoint.js';
+// add new resources here as you create them

package/src/tools/createAction.ts

@@ -0,0 +1,36 @@
+import { AnySchema } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import { V1ActionDataSchema } from '../../../src/utils/validation.js';
+import { httpClient } from '../helpers/httpClient.js';
+import { toolSuccess, toolFailure, toolError } from '../helpers/toolHelper.js';
+import { z } from 'zod';
+
+const CreateActionOutputSchema = z.object({
+  id: z.string().describe('The unique identifier of the created action'),
+  name: z.string().describe('The name of the created action'),
+});
+
+export const CreateActionTool = {
+  name: 'create_action',
+  description: 'Create a new action using the POST /action endpoint',
+  inputSchema: V1ActionDataSchema as unknown as AnySchema,
+  outputSchema: CreateActionOutputSchema as unknown as AnySchema,
+  handler: async (actionData: any) => {
+    const createData = V1ActionDataSchema.parse(actionData);
+
+    try {
+      const response = await httpClient.post('/action', createData);
+      if (response.status !== 201) {
+        return toolFailure(response);
+      }
+
+      const outputData = {
+        id: response.data.id,
+        name: response.data.operationName,
+      };
+
+      return toolSuccess(response, outputData);
+    } catch (error) {
+      return toolError(error);
+    }
+  },
+};

package/src/tools/createAgent.ts

@@ -0,0 +1,36 @@
+import { AnySchema } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import { AgentDataSchema } from '../../../src/utils/validation.js';
+import { httpClient } from '../helpers/httpClient.js';
+import { toolSuccess, toolFailure, toolError } from '../helpers/toolHelper.js';
+import { z } from 'zod';
+
+const CreateAgentOutputSchema = z.object({
+  id: z.string().describe('The unique identifier of the created agent'),
+  name: z.string().describe('The name of the created agent'),
+});
+
+export const CreateAgentTool = {
+  name: 'create_agent',
+  description: 'Create a new agent using the POST /agent endpoint',
+  inputSchema: AgentDataSchema as unknown as AnySchema,
+  outputSchema: CreateAgentOutputSchema as unknown as AnySchema,
+  handler: async (agentData: any) => {
+    const createData = AgentDataSchema.parse(agentData);
+
+    try {
+      const response = await httpClient.post('/agent', createData);
+      if (response.status !== 201) {
+        return toolFailure(response);
+      }
+
+      const outputData = {
+        id: response.data.id,
+        name: response.data.name,
+      };
+
+      return toolSuccess(response, outputData);
+    } catch (error) {
+      return toolError(error);
+    }
+  },
+};

package/src/tools/index.ts

@@ -0,0 +1,3 @@
+export { CreateAgentTool } from './createAgent.js';
+export { CreateActionTool } from './createAction.js';
+// add new tools here as you create them

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}