pulsemcp-cms-admin-mcp-server 0.6.2 → 0.6.3

package/build/index.js

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createMCPServer } from '../shared/index.js';
 import { logServerStart, logError } from '../shared/logging.js';
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 // Validate required environment variables before starting
 function validateEnvironment() {
     const required = [
@@ -33,7 +41,7 @@ async function main() {
     // Validate environment variables first
     validateEnvironment();
     // Create server using factory
-    const { server, registerHandlers } = createMCPServer();
+    const { server, registerHandlers } = createMCPServer({ version: VERSION });
     // Register all handlers (resources and tools)
     await registerHandlers(server);
     // Start server

package/build/local/src/index.integration-with-mock.js

@@ -7,11 +7,19 @@
  *
  * Mock data is passed via the PULSEMCP_MOCK_DATA environment variable.
  */
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 // IMPORTANT: This uses the package name pattern, not a relative path
 import { createMCPServer } from 'pulsemcp-cms-admin-mcp-server-shared';
 // Import the mock client factory from the shared module
 import { createMockPulseMCPAdminClient } from '../../shared/src/pulsemcp-admin-client/pulsemcp-admin-client.integration-mock.js';
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 async function main() {
     const transport = new StdioServerTransport();
     // Parse mock data from environment variable
@@ -26,7 +34,7 @@ async function main() {
     }
     // Create client factory that returns our mock
     const clientFactory = () => createMockPulseMCPAdminClient(mockData);
-    const { server, registerHandlers } = createMCPServer();
+    const { server, registerHandlers } = createMCPServer({ version: VERSION });
     await registerHandlers(server, clientFactory);
     await server.connect(transport);
 }

package/build/shared/src/pulsemcp-admin-client/lib/create-mcp-implementation.js

@@ -0,0 +1,179 @@
+export async function createMCPImplementation(apiKey, baseUrl, params) {
+    const url = new URL(`/api/implementations`, baseUrl);
+    // Build form data for the POST request
+    const formData = new URLSearchParams();
+    // Required fields for creation
+    formData.append('mcp_implementation[name]', params.name);
+    formData.append('mcp_implementation[type]', params.type);
+    // Optional fields
+    if (params.short_description !== undefined) {
+        formData.append('mcp_implementation[short_description]', params.short_description);
+    }
+    if (params.description !== undefined) {
+        formData.append('mcp_implementation[description]', params.description);
+    }
+    if (params.status !== undefined) {
+        formData.append('mcp_implementation[status]', params.status);
+    }
+    if (params.slug !== undefined) {
+        formData.append('mcp_implementation[slug]', params.slug);
+    }
+    if (params.url !== undefined) {
+        // Backend expects 'marketing_url' field, but tool exposes it as 'url' for better UX
+        formData.append('mcp_implementation[marketing_url]', params.url);
+    }
+    if (params.provider_name !== undefined) {
+        formData.append('mcp_implementation[provider_name]', params.provider_name);
+    }
+    if (params.github_stars !== undefined) {
+        formData.append('mcp_implementation[github_stars]', params.github_stars === null ? '' : params.github_stars.toString());
+    }
+    if (params.classification !== undefined) {
+        formData.append('mcp_implementation[classification]', params.classification);
+    }
+    if (params.implementation_language !== undefined) {
+        formData.append('mcp_implementation[implementation_language]', params.implementation_language);
+    }
+    if (params.mcp_server_id !== undefined) {
+        formData.append('mcp_implementation[mcp_server_id]', params.mcp_server_id === null ? '' : params.mcp_server_id.toString());
+    }
+    if (params.mcp_client_id !== undefined) {
+        formData.append('mcp_implementation[mcp_client_id]', params.mcp_client_id === null ? '' : params.mcp_client_id.toString());
+    }
+    // Provider creation/linking
+    if (params.provider_id !== undefined) {
+        formData.append('mcp_implementation[provider_id]', params.provider_id.toString());
+    }
+    if (params.provider_slug !== undefined) {
+        formData.append('mcp_implementation[provider_slug]', params.provider_slug);
+    }
+    if (params.provider_url !== undefined) {
+        formData.append('mcp_implementation[provider_url]', params.provider_url);
+    }
+    // GitHub repository fields
+    if (params.github_owner !== undefined) {
+        formData.append('mcp_implementation[github_owner]', params.github_owner);
+    }
+    if (params.github_repo !== undefined) {
+        formData.append('mcp_implementation[github_repo]', params.github_repo);
+    }
+    if (params.github_subfolder !== undefined) {
+        formData.append('mcp_implementation[github_subfolder]', params.github_subfolder);
+    }
+    // Package registry fields
+    if (params.package_registry !== undefined) {
+        formData.append('mcp_implementation[package_registry]', params.package_registry);
+    }
+    if (params.package_name !== undefined) {
+        formData.append('mcp_implementation[package_name]', params.package_name);
+    }
+    // Flags
+    if (params.recommended !== undefined) {
+        formData.append('mcp_implementation[recommended]', params.recommended.toString());
+    }
+    // Date overrides
+    if (params.created_on_override !== undefined) {
+        formData.append('mcp_implementation[created_on_override]', params.created_on_override);
+    }
+    // Tags
+    if (params.tags !== undefined) {
+        if (params.tags.length > 0) {
+            params.tags.forEach((tagSlug, index) => {
+                formData.append(`mcp_implementation[tags][${index}]`, tagSlug);
+            });
+        }
+        else {
+            // Empty array explicitly provided - send empty array marker to Rails
+            formData.append('mcp_implementation[tags]', '[]');
+        }
+    }
+    // Internal notes
+    if (params.internal_notes !== undefined) {
+        formData.append('mcp_implementation[internal_notes]', params.internal_notes);
+    }
+    // Remote endpoints
+    // Rails expects nested attributes to use the _attributes suffix for has_many associations
+    if (params.remote !== undefined) {
+        if (params.remote.length > 0) {
+            params.remote.forEach((remote, index) => {
+                if (remote.id !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][id]`, remote.id.toString());
+                }
+                if (remote.url_direct !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][url_direct]`, remote.url_direct);
+                }
+                if (remote.url_setup !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][url_setup]`, remote.url_setup);
+                }
+                if (remote.transport !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][transport]`, remote.transport);
+                }
+                if (remote.host_platform !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][host_platform]`, remote.host_platform);
+                }
+                if (remote.host_infrastructure !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][host_infrastructure]`, remote.host_infrastructure);
+                }
+                if (remote.authentication_method !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][authentication_method]`, remote.authentication_method);
+                }
+                if (remote.cost !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][cost]`, remote.cost);
+                }
+                if (remote.status !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][status]`, remote.status);
+                }
+                if (remote.display_name !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][display_name]`, remote.display_name);
+                }
+                if (remote.internal_notes !== undefined) {
+                    formData.append(`mcp_implementation[remote_attributes][${index}][internal_notes]`, remote.internal_notes);
+                }
+            });
+        }
+    }
+    // Canonical URLs
+    // Rails expects nested attributes to use the _attributes suffix for has_many associations
+    if (params.canonical !== undefined) {
+        if (params.canonical.length > 0) {
+            params.canonical.forEach((canonicalUrl, index) => {
+                formData.append(`mcp_implementation[canonical_attributes][${index}][url]`, canonicalUrl.url);
+                formData.append(`mcp_implementation[canonical_attributes][${index}][scope]`, canonicalUrl.scope);
+                if (canonicalUrl.note !== undefined) {
+                    formData.append(`mcp_implementation[canonical_attributes][${index}][note]`, canonicalUrl.note);
+                }
+            });
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            'X-API-Key': apiKey,
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+        },
+        body: formData.toString(),
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks admin privileges');
+        }
+        if (response.status === 422) {
+            const errorData = (await response.json());
+            // Handle both array format and single error string format from Rails
+            // Also handle empty arrays - an empty array should fall back to the default message
+            const errors = errorData.errors && errorData.errors.length > 0
+                ? errorData.errors
+                : errorData.error
+                    ? [errorData.error]
+                    : ['Unknown validation error'];
+            throw new Error(`Validation failed: ${errors.join(', ')}`);
+        }
+        throw new Error(`Failed to create MCP implementation: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+}

package/build/shared/src/pulsemcp-admin-client/pulsemcp-admin-client.integration-mock.js

@@ -315,6 +315,33 @@ export function createMockPulseMCPAdminClient(mockData) {
             };
             return updatedImpl;
         },
+        async createMCPImplementation(params) {
+            // Create a new implementation with mock data
+            const newImpl = {
+                id: Math.floor(Math.random() * 10000) + 1000,
+                name: params.name,
+                type: params.type,
+                status: params.status || 'draft',
+                slug: params.slug || params.name.toLowerCase().replace(/\s+/g, '-'),
+                short_description: params.short_description,
+                description: params.description,
+                classification: params.classification,
+                implementation_language: params.implementation_language,
+                url: params.url,
+                provider_name: params.provider_name,
+                github_stars: params.github_stars,
+                mcp_server_id: params.mcp_server_id,
+                mcp_client_id: params.mcp_client_id,
+                github_owner: params.github_owner,
+                github_repo: params.github_repo,
+                github_subfolder: params.github_subfolder,
+                internal_notes: params.internal_notes,
+                canonical: params.canonical,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            return newImpl;
+        },
         async sendEmail(params) {
             if (mockData.errors?.sendEmail) {
                 throw mockData.errors.sendEmail;

package/build/shared/src/server.js

@@ -72,6 +72,10 @@ export class PulseMCPAdminClient {
         const { saveMCPImplementation } = await import('./pulsemcp-admin-client/lib/save-mcp-implementation.js');
         return saveMCPImplementation(this.apiKey, this.baseUrl, id, params);
     }
+    async createMCPImplementation(params) {
+        const { createMCPImplementation } = await import('./pulsemcp-admin-client/lib/create-mcp-implementation.js');
+        return createMCPImplementation(this.apiKey, this.baseUrl, params);
+    }
     async sendEmail(params) {
         const { sendEmail } = await import('./pulsemcp-admin-client/lib/send-email.js');
         return sendEmail(this.apiKey, this.baseUrl, params);
@@ -187,10 +191,10 @@ export class PulseMCPAdminClient {
         return updateUnifiedMCPServer(this.apiKey, this.baseUrl, implementationId, params);
     }
 }
-export function createMCPServer() {
+export function createMCPServer(options) {
     const server = new Server({
         name: 'pulsemcp-cms-admin',
-        version: '0.1.0',
+        version: options.version,
     }, {
         capabilities: {
             tools: {},

package/build/shared/src/tools/save-mcp-implementation.js

@@ -1,18 +1,18 @@
 import { z } from 'zod';
 // Parameter descriptions - single source of truth
 const PARAM_DESCRIPTIONS = {
-    id: 'The ID of the MCP implementation to save/update (e.g., 11371)',
-    name: 'Updated name of the MCP implementation',
-    short_description: 'Updated short description (brief summary)',
-    description: 'Updated full description (detailed documentation)',
-    type: 'Implementation type - "server" for MCP servers, "client" for MCP clients',
+    id: 'The ID of the MCP implementation to update. Omit this field to CREATE a new implementation instead of updating an existing one.',
+    name: 'Name of the MCP implementation. Required when creating a new implementation.',
+    type: 'Implementation type - "server" for MCP servers, "client" for MCP clients. Required when creating a new implementation.',
+    short_description: 'Short description (brief summary)',
+    description: 'Full description (detailed documentation)',
     status: 'Publication status - "draft", "live", or "archived"',
-    slug: 'Updated URL-friendly slug identifier',
-    url: 'Updated URL to the implementation (GitHub repo, npm package, etc.)',
-    provider_name: 'Updated provider/author name',
-    github_stars: 'Updated GitHub star count (integer, or null if unknown)',
+    slug: 'URL-friendly slug identifier',
+    url: 'URL to the implementation (GitHub repo, npm package, etc.)',
+    provider_name: 'Provider/author name',
+    github_stars: 'GitHub star count (integer, or null if unknown)',
     classification: 'Implementation classification - "official", "community", or "reference"',
-    implementation_language: 'Updated programming language (e.g., "TypeScript", "Python", "Go")',
+    implementation_language: 'Programming language (e.g., "TypeScript", "Python", "Go")',
     mcp_server_id: 'ID of associated MCP server record (null to unlink)',
     mcp_client_id: 'ID of associated MCP client record (null to unlink)',
     // Provider creation/linking
@@ -31,11 +31,11 @@ const PARAM_DESCRIPTIONS = {
     internal_notes: 'Admin-only notes. Not displayed publicly. Used for tracking submission sources, reviewer comments, etc.',
 };
 const SaveMCPImplementationSchema = z.object({
-    id: z.number().describe(PARAM_DESCRIPTIONS.id),
+    id: z.number().optional().describe(PARAM_DESCRIPTIONS.id),
     name: z.string().optional().describe(PARAM_DESCRIPTIONS.name),
+    type: z.enum(['server', 'client']).optional().describe(PARAM_DESCRIPTIONS.type),
     short_description: z.string().optional().describe(PARAM_DESCRIPTIONS.short_description),
     description: z.string().optional().describe(PARAM_DESCRIPTIONS.description),
-    type: z.enum(['server', 'client']).optional().describe(PARAM_DESCRIPTIONS.type),
     status: z.enum(['draft', 'live', 'archived']).optional().describe(PARAM_DESCRIPTIONS.status),
     slug: z.string().optional().describe(PARAM_DESCRIPTIONS.slug),
     url: z.string().optional().describe(PARAM_DESCRIPTIONS.url),
@@ -94,11 +94,30 @@ const SaveMCPImplementationSchema = z.object({
 export function saveMCPImplementation(_server, clientFactory) {
     return {
         name: 'save_mcp_implementation',
-        description: `Save/update an MCP implementation by its ID. This tool replicates the "Save Changes" functionality from the PulseMCP Admin panel (e.g., https://admin.pulsemcp.com/mcp_implementations/11371/edit).
+        description: `Create or update an MCP implementation. This tool replicates the "Save Changes" functionality from the PulseMCP Admin panel.
+
+**Creating a new implementation:**
+- Omit the \`id\` field to create a new implementation
+- Required fields for creation: \`name\`, \`type\` (either "server" or "client")
+
+**Updating an existing implementation:**
+- Provide the \`id\` field to update an existing implementation
+- Only provided fields will be updated; omitted fields remain unchanged
+
+All business logic from the Rails controller is applied (validation, associations, callbacks).
 
-This tool allows partial updates - you only need to provide the fields you want to change. All business logic from the Rails controller is applied (validation, associations, callbacks).
+Example request (CREATE new implementation):
+{
+  "name": "My New MCP Server",
+  "type": "server",
+  "short_description": "A new MCP server for doing cool things",
+  "classification": "community",
+  "implementation_language": "TypeScript",
+  "github_owner": "myorg",
+  "github_repo": "my-mcp-server"
+}
 
-Example request (basic update):
+Example request (UPDATE existing implementation):
 {
   "id": 11371,
   "name": "GitHub MCP Server",
@@ -125,30 +144,6 @@ Example request (with remote endpoints - new remote):
   ]
 }
 
-Example request (updating existing remote by ID):
-{
-  "id": 11371,
-  "remote": [
-    {
-      "id": 123,
-      "url_direct": "https://updated-api.example.com/mcp",
-      "status": "beta"
-    }
-  ]
-}
-
-Example request (with canonical URLs):
-{
-  "id": 11371,
-  "canonical": [
-    {
-      "url": "https://github.com/owner/repo",
-      "scope": "url",
-      "note": "Official GitHub repository"
-    }
-  ]
-}
-
 Example response:
 {
   "id": 11371,
@@ -161,15 +156,15 @@ Example response:
 }
 
 Important notes:
-- Only provided fields will be updated; omitted fields remain unchanged
-- All Rails controller logic is applied (validations, associations, callbacks)
-- Use get_draft_mcp_implementations first to see current values
-- The ID parameter is required to identify which implementation to update
+- Omit \`id\` to CREATE, provide \`id\` to UPDATE
+- When creating: \`name\` and \`type\` are required
+- When updating: only provided fields will be changed
 - Setting mcp_server_id or mcp_client_id to null will unlink the association
 - Remote endpoints are for MCP servers only and configure how they can be accessed
 - Canonical URLs help identify the authoritative source for the implementation
 
 Use cases:
+- Create new MCP implementation entries
 - Update draft implementations before publishing
 - Change implementation status (draft → live, live → archived)
 - Update metadata (stars, language, classification)
@@ -307,69 +302,139 @@ Use cases:
                     description: PARAM_DESCRIPTIONS.internal_notes,
                 },
             },
-            required: ['id'],
         },
         handler: async (args) => {
             const validatedArgs = SaveMCPImplementationSchema.parse(args);
             const client = clientFactory();
             try {
-                const { id, ...params } = validatedArgs;
-                // Only update if there are actual changes
-                if (Object.keys(params).length === 0) {
+                const { id, type, ...restParams } = validatedArgs;
+                // Determine if this is a create or update operation
+                const isCreate = id === undefined;
+                if (isCreate) {
+                    // CREATE mode - validate required fields
+                    if (!validatedArgs.name) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'Error: "name" is required when creating a new MCP implementation (when "id" is omitted).',
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    if (!type) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'Error: "type" is required when creating a new MCP implementation (when "id" is omitted). Use "server" or "client".',
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Create new implementation
+                    const createParams = {
+                        name: validatedArgs.name,
+                        type: type,
+                        ...restParams,
+                    };
+                    const implementation = await client.createMCPImplementation(createParams);
+                    // Format the response for MCP
+                    let content = `Successfully created new MCP implementation!\n\n`;
+                    content += `**Name:** ${implementation.name}\n`;
+                    content += `**ID:** ${implementation.id}\n`;
+                    content += `**Slug:** ${implementation.slug}\n`;
+                    content += `**Type:** ${implementation.type}\n`;
+                    content += `**Status:** ${implementation.status}\n`;
+                    if (implementation.classification) {
+                        content += `**Classification:** ${implementation.classification}\n`;
+                    }
+                    if (implementation.implementation_language) {
+                        content += `**Language:** ${implementation.implementation_language}\n`;
+                    }
+                    if (implementation.provider_name) {
+                        content += `**Provider:** ${implementation.provider_name}\n`;
+                    }
+                    if (implementation.url) {
+                        content += `**URL:** ${implementation.url}\n`;
+                    }
+                    if (implementation.created_at) {
+                        content += `**Created:** ${new Date(implementation.created_at).toLocaleDateString()}\n`;
+                    }
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: 'No changes provided. Please specify at least one field to update.',
+                                text: content,
                             },
                         ],
                     };
                 }
-                const updateParams = params;
-                const implementation = await client.saveMCPImplementation(id, updateParams);
-                // Format the response for MCP
-                let content = `Successfully saved MCP implementation!\n\n`;
-                content += `**Name:** ${implementation.name}\n`;
-                content += `**ID:** ${implementation.id}\n`;
-                content += `**Slug:** ${implementation.slug}\n`;
-                content += `**Type:** ${implementation.type}\n`;
-                content += `**Status:** ${implementation.status}\n`;
-                if (implementation.classification) {
-                    content += `**Classification:** ${implementation.classification}\n`;
-                }
-                if (implementation.implementation_language) {
-                    content += `**Language:** ${implementation.implementation_language}\n`;
-                }
-                if (implementation.provider_name) {
-                    content += `**Provider:** ${implementation.provider_name}\n`;
-                }
-                if (implementation.url) {
-                    content += `**URL:** ${implementation.url}\n`;
-                }
-                if (implementation.github_stars !== undefined) {
-                    content += `**GitHub Stars:** ${implementation.github_stars}\n`;
-                }
-                if (implementation.mcp_server_id) {
-                    content += `**Linked MCP Server ID:** ${implementation.mcp_server_id}\n`;
-                }
-                if (implementation.mcp_client_id) {
-                    content += `**Linked MCP Client ID:** ${implementation.mcp_client_id}\n`;
-                }
-                if (implementation.updated_at) {
-                    content += `**Updated:** ${new Date(implementation.updated_at).toLocaleDateString()}\n`;
+                else {
+                    // UPDATE mode
+                    const params = { type, ...restParams };
+                    // Only update if there are actual changes
+                    if (Object.keys(params).filter((k) => params[k] !== undefined)
+                        .length === 0) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: 'No changes provided. Please specify at least one field to update.',
+                                },
+                            ],
+                        };
+                    }
+                    const updateParams = params;
+                    const implementation = await client.saveMCPImplementation(id, updateParams);
+                    // Format the response for MCP
+                    let content = `Successfully updated MCP implementation!\n\n`;
+                    content += `**Name:** ${implementation.name}\n`;
+                    content += `**ID:** ${implementation.id}\n`;
+                    content += `**Slug:** ${implementation.slug}\n`;
+                    content += `**Type:** ${implementation.type}\n`;
+                    content += `**Status:** ${implementation.status}\n`;
+                    if (implementation.classification) {
+                        content += `**Classification:** ${implementation.classification}\n`;
+                    }
+                    if (implementation.implementation_language) {
+                        content += `**Language:** ${implementation.implementation_language}\n`;
+                    }
+                    if (implementation.provider_name) {
+                        content += `**Provider:** ${implementation.provider_name}\n`;
+                    }
+                    if (implementation.url) {
+                        content += `**URL:** ${implementation.url}\n`;
+                    }
+                    if (implementation.github_stars !== undefined) {
+                        content += `**GitHub Stars:** ${implementation.github_stars}\n`;
+                    }
+                    if (implementation.mcp_server_id) {
+                        content += `**Linked MCP Server ID:** ${implementation.mcp_server_id}\n`;
+                    }
+                    if (implementation.mcp_client_id) {
+                        content += `**Linked MCP Client ID:** ${implementation.mcp_client_id}\n`;
+                    }
+                    if (implementation.updated_at) {
+                        content += `**Updated:** ${new Date(implementation.updated_at).toLocaleDateString()}\n`;
+                    }
+                    content += `\n**Fields updated:**\n`;
+                    Object.keys(params)
+                        .filter((k) => params[k] !== undefined)
+                        .forEach((field) => {
+                        content += `- ${field}\n`;
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: content,
+                            },
+                        ],
+                    };
                 }
-                content += `\n**Fields updated:**\n`;
-                Object.keys(params).forEach((field) => {
-                    content += `- ${field}\n`;
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: content,
-                        },
-                    ],
-                };
             }
             catch (error) {
                 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulsemcp-cms-admin-mcp-server",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Local implementation of PulseMCP CMS Admin MCP server",
   "mcpName": "com.pulsemcp.servers/pulsemcp-cms-admin",
   "main": "build/index.js",

package/shared/index.d.ts

@@ -1,4 +1,4 @@
 export { registerTools, createRegisterTools } from './tools.js';
-export { createMCPServer, type ClientFactory, type IPulseMCPAdminClient, PulseMCPAdminClient, } from './server.js';
+export { createMCPServer, type CreateMCPServerOptions, type ClientFactory, type IPulseMCPAdminClient, PulseMCPAdminClient, } from './server.js';
 export type { Post, PostsResponse, CreatePostParams, UpdatePostParams, ImageUploadResponse, Author, AuthorsResponse, MCPServer, MCPClient, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/shared/pulsemcp-admin-client/lib/create-mcp-implementation.d.ts

@@ -0,0 +1,3 @@
+import type { MCPImplementation, CreateMCPImplementationParams } from '../../types.js';
+export declare function createMCPImplementation(apiKey: string, baseUrl: string, params: CreateMCPImplementationParams): Promise<MCPImplementation>;
+//# sourceMappingURL=create-mcp-implementation.d.ts.map