claude-plugin-wordpress-manager 1.4.0

package/servers/wp-rest-bridge/build/tools/users.d.ts

@@ -0,0 +1,269 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const listUsersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodEnum<["view", "embed", "edit"]>>;
+    orderby: z.ZodOptional<z.ZodEnum<["id", "include", "name", "registered_date", "slug", "email", "url"]>>;
+    order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    _embed: z.ZodOptional<z.ZodBoolean>;
+    _fields: z.ZodOptional<z.ZodString>;
+    include_pagination: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    orderby?: "url" | "slug" | "id" | "name" | "include" | "registered_date" | "email" | undefined;
+    order?: "asc" | "desc" | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+    roles?: string[] | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    orderby?: "url" | "slug" | "id" | "name" | "include" | "registered_date" | "email" | undefined;
+    order?: "asc" | "desc" | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+    roles?: string[] | undefined;
+}>;
+declare const getUserSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    context: z.ZodOptional<z.ZodEnum<["view", "embed", "edit"]>>;
+    _embed: z.ZodOptional<z.ZodBoolean>;
+    _fields: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+}, {
+    id: number;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+}>;
+declare const getMeSchema: z.ZodObject<{
+    context: z.ZodOptional<z.ZodEnum<["view", "embed", "edit"]>>;
+    _fields: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    _fields?: string | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+}, {
+    _fields?: string | undefined;
+    context?: "view" | "embed" | "edit" | undefined;
+}>;
+declare const createUserSchema: z.ZodObject<{
+    username: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    nickname: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    password: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    email: string;
+    username: string;
+    password: string;
+    url?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    roles?: string[] | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    locale?: string | undefined;
+    nickname?: string | undefined;
+}, {
+    email: string;
+    username: string;
+    password: string;
+    url?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    roles?: string[] | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    locale?: string | undefined;
+    nickname?: string | undefined;
+}>;
+declare const updateUserSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    nickname: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    password: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    url?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    roles?: string[] | undefined;
+    username?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    locale?: string | undefined;
+    nickname?: string | undefined;
+    password?: string | undefined;
+}, {
+    id: number;
+    url?: string | undefined;
+    slug?: string | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    roles?: string[] | undefined;
+    username?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    locale?: string | undefined;
+    nickname?: string | undefined;
+    password?: string | undefined;
+}>;
+declare const deleteUserSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    force: z.ZodOptional<z.ZodBoolean>;
+    reassign: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    force?: boolean | undefined;
+    reassign?: number | undefined;
+}, {
+    id: number;
+    force?: boolean | undefined;
+    reassign?: number | undefined;
+}>;
+type ListUsersParams = z.infer<typeof listUsersSchema>;
+type GetUserParams = z.infer<typeof getUserSchema>;
+type CreateUserParams = z.infer<typeof createUserSchema>;
+type UpdateUserParams = z.infer<typeof updateUserSchema>;
+type DeleteUserParams = z.infer<typeof deleteUserSchema>;
+export declare const userTools: Tool[];
+export declare const userHandlers: {
+    list_users: (params: ListUsersParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    get_user: (params: GetUserParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    get_me: (params: z.infer<typeof getMeSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    create_user: (params: CreateUserParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    update_user: (params: UpdateUserParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    delete_user: (params: DeleteUserParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/users.js

@@ -0,0 +1,226 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+const listUsersSchema = z.object({
+    page: z.number().optional().describe("Page number (default 1)"),
+    per_page: z.number().min(1).max(100).optional().describe("Items per page (default 10, max 100)"),
+    search: z.string().optional().describe("Search term for user content or name"),
+    context: z.enum(['view', 'embed', 'edit']).optional().describe("Scope under which the request is made"),
+    orderby: z.enum(['id', 'include', 'name', 'registered_date', 'slug', 'email', 'url']).optional().describe("Sort users by parameter"),
+    order: z.enum(['asc', 'desc']).optional().describe("Order sort attribute ascending or descending"),
+    roles: z.array(z.string()).optional().describe("Array of role names to filter by"),
+    _embed: z.boolean().optional().describe("Inline related resources"),
+    _fields: z.string().optional().describe("Comma-separated list of fields to return"),
+    include_pagination: z.boolean().optional().describe("Include pagination metadata in response")
+});
+const getUserSchema = z.object({
+    id: z.number().describe("User ID"),
+    context: z.enum(['view', 'embed', 'edit']).optional().describe("Scope under which the request is made"),
+    _embed: z.boolean().optional().describe("Inline related resources"),
+    _fields: z.string().optional().describe("Comma-separated list of fields to return")
+}).strict();
+const getMeSchema = z.object({
+    context: z.enum(['view', 'embed', 'edit']).optional().describe("Scope under which the request is made"),
+    _fields: z.string().optional().describe("Comma-separated list of fields to return")
+}).strict();
+const createUserSchema = z.object({
+    username: z.string().describe("User login name"),
+    name: z.string().optional().describe("Display name for the user"),
+    first_name: z.string().optional().describe("First name for the user"),
+    last_name: z.string().optional().describe("Last name for the user"),
+    email: z.string().email().describe("Email address for the user"),
+    url: z.string().url().optional().describe("URL of the user"),
+    description: z.string().optional().describe("Description of the user"),
+    locale: z.string().optional().describe("Locale for the user"),
+    nickname: z.string().optional().describe("Nickname for the user"),
+    slug: z.string().optional().describe("Slug for the user"),
+    roles: z.array(z.string()).optional().describe("Roles assigned to the user"),
+    password: z.string().describe("Password for the user")
+}).strict();
+const updateUserSchema = z.object({
+    id: z.number().describe("User ID"),
+    username: z.string().optional().describe("User login name"),
+    name: z.string().optional().describe("Display name for the user"),
+    first_name: z.string().optional().describe("First name for the user"),
+    last_name: z.string().optional().describe("Last name for the user"),
+    email: z.string().email().optional().describe("Email address for the user"),
+    url: z.string().url().optional().describe("URL of the user"),
+    description: z.string().optional().describe("Description of the user"),
+    locale: z.string().optional().describe("Locale for the user"),
+    nickname: z.string().optional().describe("Nickname for the user"),
+    slug: z.string().optional().describe("Slug for the user"),
+    roles: z.array(z.string()).optional().describe("Roles assigned to the user"),
+    password: z.string().optional().describe("Password for the user")
+}).strict();
+const deleteUserSchema = z.object({
+    id: z.number().describe("User ID"),
+    force: z.boolean().optional().describe("Whether to bypass trash and force deletion"),
+    reassign: z.number().optional().describe("User ID to reassign posts to")
+}).strict();
+export const userTools = [
+    {
+        name: "list_users",
+        description: "Lists all users with filtering, sorting, and pagination options",
+        inputSchema: { type: "object", properties: listUsersSchema.shape }
+    },
+    {
+        name: "get_user",
+        description: "Gets a user by ID",
+        inputSchema: { type: "object", properties: getUserSchema.shape }
+    },
+    {
+        name: "get_me",
+        description: "Gets the currently authenticated user",
+        inputSchema: { type: "object", properties: getMeSchema.shape }
+    },
+    {
+        name: "create_user",
+        description: "Creates a new user",
+        inputSchema: { type: "object", properties: createUserSchema.shape }
+    },
+    {
+        name: "update_user",
+        description: "Updates an existing user",
+        inputSchema: { type: "object", properties: updateUserSchema.shape }
+    },
+    {
+        name: "delete_user",
+        description: "Deletes a user",
+        inputSchema: { type: "object", properties: deleteUserSchema.shape }
+    }
+];
+export const userHandlers = {
+    list_users: async (params) => {
+        try {
+            const { include_pagination, ...queryParams } = params;
+            const response = await makeWordPressRequest('GET', "users", queryParams, {
+                includePagination: include_pagination,
+            });
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error listing users: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    get_user: async (params) => {
+        try {
+            const queryParams = { context: params.context };
+            if (params._embed)
+                queryParams._embed = true;
+            if (params._fields)
+                queryParams._fields = params._fields;
+            const response = await makeWordPressRequest('GET', `users/${params.id}`, queryParams);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error getting user: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    get_me: async (params) => {
+        try {
+            const queryParams = {};
+            if (params.context)
+                queryParams.context = params.context;
+            if (params._fields)
+                queryParams._fields = params._fields;
+            const response = await makeWordPressRequest('GET', 'users/me', queryParams);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error getting current user: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    create_user: async (params) => {
+        try {
+            const response = await makeWordPressRequest('POST', "users", params);
+            const user = response;
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(user, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error creating user: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    update_user: async (params) => {
+        try {
+            const { id, ...updateData } = params;
+            const response = await makeWordPressRequest('POST', `users/${id}`, updateData);
+            const user = response;
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(user, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error updating user: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    delete_user: async (params) => {
+        try {
+            const response = await makeWordPressRequest('DELETE', `users/${params.id}`, {
+                force: params.force,
+                reassign: params.reassign
+            });
+            const user = response;
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(user, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error deleting user: ${errorMessage}` }],
+                },
+            };
+        }
+    }
+};

package/servers/wp-rest-bridge/build/types.d.ts

@@ -0,0 +1,151 @@
+interface WPContent {
+    id: number;
+    date: string;
+    date_gmt: string;
+    guid: {
+        rendered: string;
+    };
+    modified: string;
+    modified_gmt: string;
+    slug: string;
+    status: string;
+    type: string;
+    link: string;
+    title: {
+        rendered: string;
+    };
+    content: {
+        rendered: string;
+        protected: boolean;
+    };
+    excerpt: {
+        rendered: string;
+        protected: boolean;
+    };
+    author: number;
+    featured_media: number;
+    comment_status: string;
+    ping_status: string;
+    template: string;
+    meta: Record<string, any>[];
+    _links: Record<string, any>;
+}
+export interface WPPost extends WPContent {
+    format: string;
+    sticky: boolean;
+    categories: number[];
+    tags: number[];
+}
+export interface WPPage extends WPContent {
+    parent: number;
+    menu_order: number;
+}
+export interface WPCategory {
+    id: number;
+    count: number;
+    description: string;
+    link: string;
+    name: string;
+    slug: string;
+    taxonomy: string;
+    parent: number;
+    meta: Record<string, any>[];
+    _links: Record<string, any>;
+}
+export interface WPUser {
+    id: number;
+    username: string;
+    name: string;
+    first_name: string;
+    last_name: string;
+    email: string;
+    url: string;
+    description: string;
+    link: string;
+    locale: string;
+    nickname: string;
+    slug: string;
+    roles: string[];
+    registered_date: string;
+    capabilities: Record<string, boolean>;
+    extra_capabilities: Record<string, boolean>;
+    avatar_urls: Record<string, string>;
+    meta: Record<string, any>[];
+    _links: Record<string, any>;
+}
+export interface WPPlugin {
+    plugin: string;
+    status: string;
+    name: string;
+    plugin_uri: string;
+    author: string;
+    author_uri: string;
+    description: {
+        raw: string;
+        rendered: string;
+    };
+    version: string;
+    network_only: boolean;
+    requires_wp: string;
+    requires_php: string;
+    textdomain: string;
+}
+export interface WPComment {
+    id: number;
+    post: number;
+    parent: number;
+    author: number;
+    author_name: string;
+    author_url: string;
+    author_email?: string;
+    author_ip?: string;
+    author_user_agent?: string;
+    date: string;
+    date_gmt: string;
+    content: {
+        rendered: string;
+        raw?: string;
+    };
+    link: string;
+    status: string;
+    type: string;
+    meta: Record<string, any>[];
+    _links: Record<string, any>;
+}
+export interface WPCustomPost extends WPContent {
+    [key: string]: any;
+}
+export interface WPPostType {
+    slug: string;
+    name: string;
+    description: string;
+    hierarchical: boolean;
+    rest_base: string;
+    supports: string[];
+    taxonomies: string[];
+    labels: Record<string, string>;
+    _links: Record<string, any>;
+}
+export interface WPTaxonomy {
+    slug: string;
+    name: string;
+    description: string;
+    types: string[];
+    hierarchical: boolean;
+    rest_base: string;
+    labels: Record<string, string>;
+    _links: Record<string, any>;
+}
+export interface WPTerm {
+    id: number;
+    count: number;
+    description: string;
+    link: string;
+    name: string;
+    slug: string;
+    taxonomy: string;
+    parent: number;
+    meta: Record<string, any>[];
+    _links: Record<string, any>;
+}
+export {};

package/servers/wp-rest-bridge/build/types.js

@@ -0,0 +1,2 @@
+// src/types/wordpress-types.ts
+export {};

package/servers/wp-rest-bridge/build/wordpress.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Parse WP_SITES_CONFIG JSON and initialize all site clients
+ */
+export declare function initWordPress(): Promise<void>;
+/**
+ * Switch the active site
+ */
+export declare function switchSite(siteId: string): string;
+/**
+ * List all configured sites
+ */
+export declare function listSites(): string[];
+/**
+ * Get the active site ID
+ */
+export declare function getActiveSite(): string;
+/**
+ * Log to stderr (safe for MCP stdio transport)
+ */
+export declare function logToStderr(message: string): void;
+export declare const logToFile: typeof logToStderr;
+export interface WordPressRequestOptions {
+    headers?: Record<string, string>;
+    isFormData?: boolean;
+    rawResponse?: boolean;
+    siteId?: string;
+    namespace?: string;
+    timeout?: number;
+    includePagination?: boolean;
+}
+export interface PaginatedResponse<T = any> {
+    items: T;
+    pagination: {
+        total: number;
+        totalPages: number;
+        page: number;
+        perPage: number;
+    };
+}
+/**
+ * Make a request to the WordPress API (active site or specific site).
+ * Includes automatic retry with exponential backoff and concurrency limiting.
+ */
+export declare function makeWordPressRequest(method: string, endpoint: string, data?: any, options?: WordPressRequestOptions): Promise<any>;
+/**
+ * Search the WordPress.org Plugin Repository
+ */
+export declare function searchWordPressPluginRepository(searchQuery: string, page?: number, perPage?: number): Promise<any>;