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

package/README.md

@@ -77,6 +77,11 @@ This server is built and tested on macOS with Claude Desktop. It should work wit
 | `list_mcp_servers`                     | mcp_servers        | read       | List/search MCP servers with filtering by status, classification, pagination. |
 | `get_mcp_server`                       | mcp_servers        | read       | Get detailed MCP server info by slug (unified view of all admin UI fields).   |
 | `update_mcp_server`                    | mcp_servers        | write      | Update an MCP server's fields (all admin UI fields supported).                |
+| `get_redirects`                        | redirects          | read       | List URL redirects with search, status filtering, and pagination.             |
+| `get_redirect`                         | redirects          | read       | Get detailed redirect info by ID.                                             |
+| `create_redirect`                      | redirects          | write      | Create a new URL redirect entry.                                              |
+| `update_redirect`                      | redirects          | write      | Update an existing URL redirect by ID.                                        |
+| `delete_redirect`                      | redirects          | write      | Delete a URL redirect by ID (irreversible).                                   |
 
 # Tool Groups
 
@@ -105,6 +110,8 @@ This server organizes tools into groups that can be selectively enabled or disab
 | `mcp_jsons_readonly`          | 2     | MCP JSON configurations read-only            |
 | `mcp_servers`                 | 3     | Full MCP servers management (read + write)   |
 | `mcp_servers_readonly`        | 2     | MCP servers read-only (list, get)            |
+| `redirects`                   | 5     | Full URL redirect management (read + write)  |
+| `redirects_readonly`          | 2     | URL redirects read-only (list, get)          |
 
 ### Tools by Group
 
@@ -130,12 +137,15 @@ This server organizes tools into groups that can be selectively enabled or disab
 - **mcp_servers** / **mcp_servers_readonly**:
   - Read-only: `list_mcp_servers`, `get_mcp_server`
   - Write: `update_mcp_server`
+- **redirects** / **redirects_readonly**:
+  - Read-only: `get_redirects`, `get_redirect`
+  - Write: `create_redirect`, `update_redirect`, `delete_redirect`
 
 ## Environment Variables
 
-| Variable      | Description                                 | Default                                                                                                                      |
-| ------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `TOOL_GROUPS` | Comma-separated list of enabled tool groups | `newsletter,server_queue,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers` (all base groups) |
+| Variable      | Description                                 | Default                                                                                                                                |
+| ------------- | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `TOOL_GROUPS` | Comma-separated list of enabled tool groups | `newsletter,server_queue,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers,redirects` (all base groups) |
 
 ## Examples
 
@@ -160,7 +170,7 @@ TOOL_GROUPS=server_queue_readonly
 Enable all groups with read-only access:
 
 ```bash
-TOOL_GROUPS=newsletter_readonly,server_queue_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly
+TOOL_GROUPS=newsletter_readonly,server_queue_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly,redirects_readonly
 ```
 
 Mix full and read-only access per group:
@@ -296,7 +306,7 @@ Add to your Claude Desktop configuration:
       "args": ["/path/to/pulsemcp-cms-admin/local/build/index.js"],
       "env": {
         "PULSEMCP_ADMIN_API_KEY": "your-api-key-here",
-        "TOOL_GROUPS": "newsletter,server_queue,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers"
+        "TOOL_GROUPS": "newsletter,server_queue,official_queue,unofficial_mirrors,official_mirrors,tenants,mcp_jsons,mcp_servers,redirects"
       }
     }
   }
@@ -313,7 +323,7 @@ For read-only access:
       "args": ["/path/to/pulsemcp-cms-admin/local/build/index.js"],
       "env": {
         "PULSEMCP_ADMIN_API_KEY": "your-api-key-here",
-        "TOOL_GROUPS": "newsletter_readonly,server_queue_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly"
+        "TOOL_GROUPS": "newsletter_readonly,server_queue_readonly,official_queue_readonly,unofficial_mirrors_readonly,official_mirrors_readonly,tenants_readonly,mcp_jsons_readonly,mcp_servers_readonly,redirects_readonly"
       }
     }
   }

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

@@ -0,0 +1,41 @@
+export async function createRedirect(apiKey, baseUrl, params) {
+    const url = new URL('/api/redirects', baseUrl);
+    const body = {
+        from: params.from,
+        to: params.to,
+    };
+    if (params.status !== undefined) {
+        body.status = params.status;
+    }
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            'X-API-Key': apiKey,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks write privileges');
+        }
+        if (response.status === 422) {
+            const errorData = (await response.json());
+            throw new Error(`Validation failed: ${errorData.errors?.join(', ') || 'Unknown error'}`);
+        }
+        throw new Error(`Failed to create redirect: ${response.status} ${response.statusText}`);
+    }
+    const redirect = (await response.json());
+    return {
+        id: redirect.id,
+        from: redirect.from,
+        to: redirect.to,
+        status: redirect.status,
+        created_at: redirect.created_at,
+        updated_at: redirect.updated_at,
+    };
+}

package/build/shared/src/pulsemcp-admin-client/lib/delete-redirect.js

@@ -0,0 +1,24 @@
+export async function deleteRedirect(apiKey, baseUrl, id) {
+    const url = new URL(`/api/redirects/${id}`, baseUrl);
+    const response = await fetch(url.toString(), {
+        method: 'DELETE',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks write privileges');
+        }
+        if (response.status === 404) {
+            throw new Error(`Redirect with ID ${id} not found`);
+        }
+        throw new Error(`Failed to delete redirect: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data;
+}

package/build/shared/src/pulsemcp-admin-client/lib/get-redirect.js

@@ -0,0 +1,31 @@
+export async function getRedirect(apiKey, baseUrl, id) {
+    const url = new URL(`/api/redirects/${id}`, baseUrl);
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    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 === 404) {
+            throw new Error(`Redirect with ID ${id} not found`);
+        }
+        throw new Error(`Failed to fetch redirect: ${response.status} ${response.statusText}`);
+    }
+    const redirect = (await response.json());
+    return {
+        id: redirect.id,
+        from: redirect.from,
+        to: redirect.to,
+        status: redirect.status,
+        created_at: redirect.created_at,
+        updated_at: redirect.updated_at,
+    };
+}

package/build/shared/src/pulsemcp-admin-client/lib/get-redirects.js

@@ -0,0 +1,52 @@
+function mapRedirect(redirect) {
+    return {
+        id: redirect.id,
+        from: redirect.from,
+        to: redirect.to,
+        status: redirect.status,
+        created_at: redirect.created_at,
+        updated_at: redirect.updated_at,
+    };
+}
+export async function getRedirects(apiKey, baseUrl, params) {
+    const url = new URL('/api/redirects', baseUrl);
+    if (params?.q) {
+        url.searchParams.append('q', params.q);
+    }
+    if (params?.status) {
+        url.searchParams.append('status', params.status);
+    }
+    if (params?.limit) {
+        url.searchParams.append('limit', params.limit.toString());
+    }
+    if (params?.offset) {
+        url.searchParams.append('offset', params.offset.toString());
+    }
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': apiKey,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks admin privileges');
+        }
+        throw new Error(`Failed to fetch redirects: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return {
+        redirects: data.data.map(mapRedirect),
+        pagination: {
+            current_page: data.meta.current_page,
+            total_pages: data.meta.total_pages,
+            total_count: data.meta.total_count,
+            has_next: data.meta.has_next,
+            limit: data.meta.limit,
+        },
+    };
+}

package/build/shared/src/pulsemcp-admin-client/lib/update-redirect.js

@@ -0,0 +1,47 @@
+export async function updateRedirect(apiKey, baseUrl, id, params) {
+    const url = new URL(`/api/redirects/${id}`, baseUrl);
+    const body = {};
+    if (params.from !== undefined) {
+        body.from = params.from;
+    }
+    if (params.to !== undefined) {
+        body.to = params.to;
+    }
+    if (params.status !== undefined) {
+        body.status = params.status;
+    }
+    const response = await fetch(url.toString(), {
+        method: 'PUT',
+        headers: {
+            'X-API-Key': apiKey,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid API key');
+        }
+        if (response.status === 403) {
+            throw new Error('User lacks write privileges');
+        }
+        if (response.status === 404) {
+            throw new Error(`Redirect with ID ${id} not found`);
+        }
+        if (response.status === 422) {
+            const errorData = (await response.json());
+            throw new Error(`Validation failed: ${errorData.errors?.join(', ') || 'Unknown error'}`);
+        }
+        throw new Error(`Failed to update redirect: ${response.status} ${response.statusText}`);
+    }
+    const redirect = (await response.json());
+    return {
+        id: redirect.id,
+        from: redirect.from,
+        to: redirect.to,
+        status: redirect.status,
+        created_at: redirect.created_at,
+        updated_at: redirect.updated_at,
+    };
+}

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

@@ -811,5 +811,42 @@ export function createMockPulseMCPAdminClient(mockData) {
                 updated_at: new Date().toISOString(),
             };
         },
+        // Redirect REST API methods (stub implementations)
+        async getRedirects() {
+            return { redirects: [], pagination: { current_page: 1, total_pages: 1, total_count: 0 } };
+        },
+        async getRedirect(id) {
+            return {
+                id,
+                from: '/old-page',
+                to: '/new-page',
+                status: 'active',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async createRedirect(params) {
+            return {
+                id: 1,
+                from: params.from,
+                to: params.to,
+                status: params.status || 'draft',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async updateRedirect(id, params) {
+            return {
+                id,
+                from: params.from || '/old-page',
+                to: params.to || '/new-page',
+                status: params.status || 'active',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async deleteRedirect() {
+            return { success: true, message: 'Redirect deleted' };
+        },
     };
 }

package/build/shared/src/server.js

@@ -190,6 +190,27 @@ export class PulseMCPAdminClient {
         const { updateUnifiedMCPServer } = await import('./pulsemcp-admin-client/lib/update-unified-mcp-server.js');
         return updateUnifiedMCPServer(this.apiKey, this.baseUrl, implementationId, params);
     }
+    // Redirect REST API methods
+    async getRedirects(params) {
+        const { getRedirects } = await import('./pulsemcp-admin-client/lib/get-redirects.js');
+        return getRedirects(this.apiKey, this.baseUrl, params);
+    }
+    async getRedirect(id) {
+        const { getRedirect } = await import('./pulsemcp-admin-client/lib/get-redirect.js');
+        return getRedirect(this.apiKey, this.baseUrl, id);
+    }
+    async createRedirect(params) {
+        const { createRedirect } = await import('./pulsemcp-admin-client/lib/create-redirect.js');
+        return createRedirect(this.apiKey, this.baseUrl, params);
+    }
+    async updateRedirect(id, params) {
+        const { updateRedirect } = await import('./pulsemcp-admin-client/lib/update-redirect.js');
+        return updateRedirect(this.apiKey, this.baseUrl, id, params);
+    }
+    async deleteRedirect(id) {
+        const { deleteRedirect } = await import('./pulsemcp-admin-client/lib/delete-redirect.js');
+        return deleteRedirect(this.apiKey, this.baseUrl, id);
+    }
 }
 export function createMCPServer(options) {
     const server = new Server({

package/build/shared/src/tools/create-redirect.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    from: 'The source path to redirect from (e.g., "/old-page")',
+    to: 'The destination path or URL to redirect to (e.g., "/new-page" or "https://example.com")',
+    status: 'The status of the redirect (draft, active, paused, archived). Defaults to draft.',
+};
+const CreateRedirectSchema = z.object({
+    from: z.string().describe(PARAM_DESCRIPTIONS.from),
+    to: z.string().describe(PARAM_DESCRIPTIONS.to),
+    status: z
+        .enum(['draft', 'active', 'paused', 'archived'])
+        .optional()
+        .describe(PARAM_DESCRIPTIONS.status),
+});
+export function createRedirect(_server, clientFactory) {
+    return {
+        name: 'create_redirect',
+        description: `Create a new URL redirect entry. Redirects manage URL routing on the PulseMCP website.
+
+Example request:
+{
+  "from": "/old-page",
+  "to": "/new-page",
+  "status": "draft"
+}
+
+Use cases:
+- Create a new redirect when moving content to a new URL
+- Set up redirects for deprecated pages
+- Create draft redirects for review before activation`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                from: { type: 'string', description: PARAM_DESCRIPTIONS.from },
+                to: { type: 'string', description: PARAM_DESCRIPTIONS.to },
+                status: {
+                    type: 'string',
+                    enum: ['draft', 'active', 'paused', 'archived'],
+                    description: PARAM_DESCRIPTIONS.status,
+                },
+            },
+            required: ['from', 'to'],
+        },
+        handler: async (args) => {
+            const validatedArgs = CreateRedirectSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const redirect = await client.createRedirect({
+                    from: validatedArgs.from,
+                    to: validatedArgs.to,
+                    status: validatedArgs.status,
+                });
+                let content = `Successfully created redirect!\n\n`;
+                content += `**ID:** ${redirect.id}\n`;
+                content += `**From:** ${redirect.from}\n`;
+                content += `**To:** ${redirect.to}\n`;
+                content += `**Status:** ${redirect.status}\n`;
+                if (redirect.created_at) {
+                    content += `**Created:** ${redirect.created_at}\n`;
+                }
+                return { content: [{ type: 'text', text: content }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error creating redirect: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/build/shared/src/tools/delete-redirect.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    id: 'The ID of the redirect to delete',
+};
+const DeleteRedirectSchema = z.object({
+    id: z.number().describe(PARAM_DESCRIPTIONS.id),
+});
+export function deleteRedirect(_server, clientFactory) {
+    return {
+        name: 'delete_redirect',
+        description: `Delete a URL redirect by its ID. This action is irreversible.
+
+Use cases:
+- Remove duplicate or outdated redirects
+- Clean up test data
+- Remove redirects that were incorrectly created`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'number', description: PARAM_DESCRIPTIONS.id },
+            },
+            required: ['id'],
+        },
+        handler: async (args) => {
+            const validatedArgs = DeleteRedirectSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const result = await client.deleteRedirect(validatedArgs.id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Successfully deleted redirect (ID: ${validatedArgs.id}).\n\n${result.message}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error deleting redirect: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/build/shared/src/tools/get-redirect.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    id: 'The ID of the redirect to retrieve',
+};
+const GetRedirectSchema = z.object({
+    id: z.number().describe(PARAM_DESCRIPTIONS.id),
+});
+export function getRedirect(_server, clientFactory) {
+    return {
+        name: 'get_redirect',
+        description: `Retrieve a single URL redirect by its ID. Returns detailed information including the from/to paths and status.
+
+Example response:
+{
+  "id": 123,
+  "from": "/old-page",
+  "to": "/new-page",
+  "status": "active",
+  "created_at": "2024-01-15T10:00:00Z",
+  "updated_at": "2024-01-15T10:00:00Z"
+}
+
+Use cases:
+- Get detailed information about a specific redirect
+- Check the current state of a redirect before updating
+- Verify redirect configuration`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'number', description: PARAM_DESCRIPTIONS.id },
+            },
+            required: ['id'],
+        },
+        handler: async (args) => {
+            const validatedArgs = GetRedirectSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const redirect = await client.getRedirect(validatedArgs.id);
+                let content = `**Redirect Details**\n\n`;
+                content += `**ID:** ${redirect.id}\n`;
+                content += `**From:** ${redirect.from}\n`;
+                content += `**To:** ${redirect.to}\n`;
+                content += `**Status:** ${redirect.status}\n`;
+                if (redirect.created_at) {
+                    content += `**Created:** ${redirect.created_at}\n`;
+                }
+                if (redirect.updated_at) {
+                    content += `**Updated:** ${redirect.updated_at}\n`;
+                }
+                return { content: [{ type: 'text', text: content }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching redirect: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/build/shared/src/tools/get-redirects.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    q: 'Search query to filter by from or to paths',
+    status: 'Filter by status (draft, active, paused, archived)',
+    limit: 'Results per page, range 1-100. Default: 30',
+    offset: 'Pagination offset. Default: 0',
+};
+const GetRedirectsSchema = z.object({
+    q: z.string().optional().describe(PARAM_DESCRIPTIONS.q),
+    status: z
+        .enum(['draft', 'active', 'paused', 'archived'])
+        .optional()
+        .describe(PARAM_DESCRIPTIONS.status),
+    limit: z.number().min(1).max(100).optional().describe(PARAM_DESCRIPTIONS.limit),
+    offset: z.number().min(0).optional().describe(PARAM_DESCRIPTIONS.offset),
+});
+export function getRedirects(_server, clientFactory) {
+    return {
+        name: 'get_redirects',
+        description: `Retrieve a paginated list of URL redirects from the PulseMCP Admin API. Redirects manage URL routing on the PulseMCP website.
+
+Example response:
+{
+  "redirects": [
+    {
+      "id": 123,
+      "from": "/old-page",
+      "to": "/new-page",
+      "status": "active"
+    }
+  ],
+  "pagination": { "current_page": 1, "total_pages": 5, "total_count": 150 }
+}
+
+Use cases:
+- Browse redirects to find existing URL mappings
+- Search for specific redirects by path
+- Filter redirects by status (draft, active, paused, archived)
+- Review redirects before activating or modifying them`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                q: { type: 'string', description: PARAM_DESCRIPTIONS.q },
+                status: {
+                    type: 'string',
+                    enum: ['draft', 'active', 'paused', 'archived'],
+                    description: PARAM_DESCRIPTIONS.status,
+                },
+                limit: { type: 'number', minimum: 1, maximum: 100, description: PARAM_DESCRIPTIONS.limit },
+                offset: { type: 'number', minimum: 0, description: PARAM_DESCRIPTIONS.offset },
+            },
+        },
+        handler: async (args) => {
+            const validatedArgs = GetRedirectsSchema.parse(args);
+            const client = clientFactory();
+            try {
+                const response = await client.getRedirects({
+                    q: validatedArgs.q,
+                    status: validatedArgs.status,
+                    limit: validatedArgs.limit,
+                    offset: validatedArgs.offset,
+                });
+                let content = `Found ${response.redirects.length} redirects`;
+                if (response.pagination) {
+                    content += ` (page ${response.pagination.current_page} of ${response.pagination.total_pages}, total: ${response.pagination.total_count})`;
+                }
+                content += ':\n\n';
+                for (const [index, redirect] of response.redirects.entries()) {
+                    content += `${index + 1}. **${redirect.from}** → ${redirect.to} (ID: ${redirect.id})\n`;
+                    content += `   Status: ${redirect.status}\n`;
+                    if (redirect.created_at) {
+                        content += `   Created: ${new Date(redirect.created_at).toLocaleDateString()}\n`;
+                    }
+                    content += '\n';
+                }
+                return { content: [{ type: 'text', text: content.trim() }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching redirects: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}