@mangerik/wordpress-mcp 0.1.0

package/dist/tools/jwt.js

@@ -0,0 +1,17 @@
+/**
+ * JWT auth helper tools (only useful when WP_AUTH_MODE=jwt).
+ * Most users won't need to call these directly — the server fetches a token
+ * automatically at startup. They're handy for diagnostics.
+ */
+export const jwtTools = (wp) => [
+    {
+        name: "wp_jwt_validate",
+        title: "JWT: validate current token",
+        description: "POST /jwt-auth/v1/token/validate — confirms the JWT in use is valid. " +
+            "Only useful in JWT auth mode.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async () => wp.validateJwt(),
+    },
+];
+//# sourceMappingURL=jwt.js.map

package/dist/tools/media.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const mediaTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=media.d.ts.map

package/dist/tools/media.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export const mediaTools = (wp) => [
+    {
+        name: "wp_get_media",
+        title: "List media",
+        description: "List WordPress media items (images, videos, files).",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            search: z.string().optional(),
+            media_type: z.enum(["image", "video", "audio", "application"]).optional(),
+            mime_type: z.string().optional(),
+            parent: z.number().int().optional(),
+            orderby: z.enum(["date", "id", "title", "modified", "slug"]).optional(),
+            order: z.enum(["asc", "desc"]).optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const result = await wp.media.list(input);
+            return { media: result.data, total: result.total, total_pages: result.pages };
+        },
+    },
+    {
+        name: "wp_get_media_item",
+        title: "Get a media item",
+        description: "Get a single media item by ID.",
+        inputSchema: { id: z.number().int().positive() },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => wp.media.get(input.id),
+    },
+    {
+        name: "wp_upload_media_file",
+        title: "Upload media from local file",
+        description: "Upload a media file from an absolute local path.",
+        inputSchema: {
+            file_path: z.string().min(1),
+            title: z.string().optional(),
+            alt_text: z.string().optional(),
+            caption: z.string().optional(),
+            description: z.string().optional(),
+            post: z.number().int().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { file_path, ...metadata } = input;
+            return wp.uploadMediaFromFile(file_path, metadata);
+        },
+    },
+    {
+        name: "wp_upload_media_url",
+        title: "Upload media from URL",
+        description: "Download a remote file and upload it to WordPress.",
+        inputSchema: {
+            url: z.string().url(),
+            title: z.string().optional(),
+            alt_text: z.string().optional(),
+            caption: z.string().optional(),
+            description: z.string().optional(),
+            post: z.number().int().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { url, ...metadata } = input;
+            return wp.uploadMediaFromUrl(url, metadata);
+        },
+    },
+    {
+        name: "wp_update_media",
+        title: "Update media metadata",
+        description: "Update metadata of an existing media item.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            title: z.string().optional(),
+            alt_text: z.string().optional(),
+            caption: z.string().optional(),
+            description: z.string().optional(),
+            post: z.number().int().optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...data } = input;
+            return wp.media.update(id, data);
+        },
+    },
+    {
+        name: "wp_delete_media",
+        title: "Delete media",
+        description: "Permanently delete a media item. WordPress does not trash media; this is irreversible.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            force: z.boolean().optional(),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, force = true } = input;
+            return wp.media.remove(id, force);
+        },
+    },
+];
+//# sourceMappingURL=media.js.map

package/dist/tools/multisite.d.ts

@@ -0,0 +1,17 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+/**
+ * Multisite tools.
+ *
+ * Important: as of WordPress 6.x, **core does NOT yet ship a `/wp/v2/sites`
+ * endpoint** — it is on the multisite roadmap but unreleased. The tools below
+ * call `wp/v2/sites` (and `wp/v2/networks` where useful) on the assumption
+ * that a Multisite REST plugin (e.g. brettkrueger/multisite-rest-api) is
+ * installed. If you get a 404 with code `rest_no_route`, the plugin is
+ * missing or your build of WordPress doesn't expose the endpoint.
+ *
+ * Fallback: use the generic `wp_list_items` / `wp_create_item` tools on
+ * a custom namespace your plugin exposes.
+ */
+export declare const multisiteTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=multisite.d.ts.map

package/dist/tools/multisite.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+/**
+ * Multisite tools.
+ *
+ * Important: as of WordPress 6.x, **core does NOT yet ship a `/wp/v2/sites`
+ * endpoint** — it is on the multisite roadmap but unreleased. The tools below
+ * call `wp/v2/sites` (and `wp/v2/networks` where useful) on the assumption
+ * that a Multisite REST plugin (e.g. brettkrueger/multisite-rest-api) is
+ * installed. If you get a 404 with code `rest_no_route`, the plugin is
+ * missing or your build of WordPress doesn't expose the endpoint.
+ *
+ * Fallback: use the generic `wp_list_items` / `wp_create_item` tools on
+ * a custom namespace your plugin exposes.
+ */
+export const multisiteTools = (wp) => [
+    {
+        name: "ms_list_sites",
+        title: "Multisite: list sites",
+        description: "List all sites in the network. Requires a Multisite REST plugin to be installed. " +
+            "Returns 404 (rest_no_route) on plain core WP.",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            search: z.string().optional(),
+            network: z.number().int().optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/sites", input);
+            return { sites: r.data, total: r.total };
+        },
+    },
+    {
+        name: "ms_get_site",
+        title: "Multisite: get site",
+        description: "Get a single network site by blog ID.",
+        inputSchema: { id: z.number().int().positive() },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => wp.get("wp/v2/sites", input.id),
+    },
+    {
+        name: "ms_create_site",
+        title: "Multisite: create site",
+        description: "Create a new site (subsite) in the network. Field names follow the multisite-rest-api plugin conventions; adjust if your plugin differs.",
+        inputSchema: {
+            domain: z.string().min(1),
+            path: z.string().default("/"),
+            title: z.string().optional(),
+            network_id: z.number().int().optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => wp.create("wp/v2/sites", input),
+    },
+    {
+        name: "ms_update_site",
+        title: "Multisite: update site",
+        description: "Update a network site by blog ID.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            domain: z.string().optional(),
+            path: z.string().optional(),
+            title: z.string().optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...data } = input;
+            return wp.update("wp/v2/sites", id, data);
+        },
+    },
+    {
+        name: "ms_delete_site",
+        title: "Multisite: delete site",
+        description: "Delete a network site. Always destructive — there is no trash for sites.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            force: z.boolean().optional(),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, force = true } = input;
+            return wp.remove("wp/v2/sites", id, force);
+        },
+    },
+    // ── Networks ───────────────────────────────────────────────────────────
+    {
+        name: "ms_list_networks",
+        title: "Multisite: list networks",
+        description: "List networks (multi-network installs). Same plugin requirement as sites.",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const r = await wp.list("wp/v2/networks", input);
+            return { networks: r.data, total: r.total };
+        },
+    },
+    {
+        name: "ms_get_network",
+        title: "Multisite: get network",
+        description: "Get a single network by ID.",
+        inputSchema: { id: z.number().int().positive() },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => wp.get("wp/v2/networks", input.id),
+    },
+];
+//# sourceMappingURL=multisite.js.map

package/dist/tools/pages.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const pageTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=pages.d.ts.map

package/dist/tools/pages.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export const pageTools = (wp) => [
+    {
+        name: "wp_get_pages",
+        title: "List pages",
+        description: "List WordPress pages.",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            search: z.string().optional(),
+            status: z.enum(["publish", "draft", "private", "pending", "any"]).optional(),
+            parent: z.number().int().optional(),
+            orderby: z
+                .enum(["date", "id", "title", "modified", "menu_order", "slug"])
+                .optional(),
+            order: z.enum(["asc", "desc"]).optional(),
+            _fields: z.string().optional(),
+            _embed: z.boolean().optional(),
+            context: z.enum(["view", "edit"]).optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const result = await wp.pages.list(input);
+            return { pages: result.data, total: result.total, total_pages: result.pages };
+        },
+    },
+    {
+        name: "wp_get_page",
+        title: "Get a page",
+        description: "Get a single WordPress page by ID.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            context: z.enum(["view", "edit"]).optional(),
+            _fields: z.string().optional(),
+            _embed: z.boolean().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...rest } = input;
+            return wp.pages.get(id, rest);
+        },
+    },
+    {
+        name: "wp_create_page",
+        title: "Create a page",
+        description: "Create a new WordPress page (default status=draft).",
+        inputSchema: {
+            title: z.string().min(1),
+            content: z.string(),
+            excerpt: z.string().optional(),
+            status: z.enum(["publish", "draft", "private", "pending"]).optional(),
+            slug: z.string().optional(),
+            parent: z.number().int().optional(),
+            menu_order: z.number().int().optional(),
+            featured_media: z.number().int().optional(),
+            template: z.string().optional(),
+            comment_status: z.enum(["open", "closed"]).optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => wp.pages.create({ status: "draft", ...input }),
+    },
+    {
+        name: "wp_update_page",
+        title: "Update a page",
+        description: "Update an existing WordPress page.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            title: z.string().optional(),
+            content: z.string().optional(),
+            excerpt: z.string().optional(),
+            status: z.enum(["publish", "draft", "private", "pending"]).optional(),
+            slug: z.string().optional(),
+            parent: z.number().int().optional(),
+            menu_order: z.number().int().optional(),
+            featured_media: z.number().int().optional(),
+            template: z.string().optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...data } = input;
+            return wp.pages.update(id, data);
+        },
+    },
+    {
+        name: "wp_delete_page",
+        title: "Delete a page",
+        description: "Move a page to trash, or permanently delete with force=true.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            force: z.boolean().optional(),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, force = false } = input;
+            return wp.pages.remove(id, force);
+        },
+    },
+];
+//# sourceMappingURL=pages.js.map

package/dist/tools/posts.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const postTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=posts.d.ts.map

package/dist/tools/posts.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+const statusEnum = z.enum([
+    "publish",
+    "draft",
+    "private",
+    "pending",
+    "future",
+]);
+const statusFilter = z.enum([...statusEnum.options, "any"]);
+const orderEnum = z.enum(["asc", "desc"]);
+export const postTools = (wp) => [
+    {
+        name: "wp_get_posts",
+        title: "List posts",
+        description: "List WordPress posts with filters. Use `_fields` to keep responses small (e.g. 'id,title,slug').",
+        inputSchema: {
+            page: z.number().int().positive().optional(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            search: z.string().optional(),
+            status: statusFilter.optional(),
+            categories: z.array(z.number().int()).optional(),
+            tags: z.array(z.number().int()).optional(),
+            author: z.number().int().optional(),
+            orderby: z
+                .enum(["date", "id", "title", "modified", "relevance", "rand", "slug"])
+                .optional(),
+            order: orderEnum.optional(),
+            after: z.string().optional().describe("ISO8601 lower bound (inclusive)"),
+            before: z.string().optional().describe("ISO8601 upper bound (inclusive)"),
+            slug: z.array(z.string()).optional(),
+            _fields: z.string().optional(),
+            _embed: z.boolean().optional(),
+            context: z.enum(["view", "edit"]).optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const result = await wp.posts.list(input);
+            return { posts: result.data, total: result.total, total_pages: result.pages };
+        },
+    },
+    {
+        name: "wp_get_post",
+        title: "Get a post",
+        description: "Get a single WordPress post by ID.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            context: z.enum(["view", "edit"]).optional(),
+            _fields: z.string().optional(),
+            _embed: z.boolean().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...rest } = input;
+            return wp.posts.get(id, rest);
+        },
+    },
+    {
+        name: "wp_create_post",
+        title: "Create a post",
+        description: "Create a new WordPress post. Defaults to status=draft for safety. " +
+            "Set `meta` to write custom fields (must be registered server-side).",
+        inputSchema: {
+            title: z.string().min(1),
+            content: z.string(),
+            excerpt: z.string().optional(),
+            status: statusEnum.optional(),
+            slug: z.string().optional(),
+            categories: z.array(z.number().int()).optional(),
+            tags: z.array(z.number().int()).optional(),
+            featured_media: z.number().int().optional(),
+            date: z.string().optional(),
+            comment_status: z.enum(["open", "closed"]).optional(),
+            ping_status: z.enum(["open", "closed"]).optional(),
+            format: z
+                .enum([
+                "standard",
+                "aside",
+                "chat",
+                "gallery",
+                "link",
+                "image",
+                "quote",
+                "status",
+                "video",
+                "audio",
+            ])
+                .optional(),
+            sticky: z.boolean().optional(),
+            author: z.number().int().optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const body = { status: "draft", ...input };
+            return wp.posts.create(body);
+        },
+    },
+    {
+        name: "wp_update_post",
+        title: "Update a post",
+        description: "Update an existing WordPress post.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            title: z.string().optional(),
+            content: z.string().optional(),
+            excerpt: z.string().optional(),
+            status: statusEnum.optional(),
+            slug: z.string().optional(),
+            categories: z.array(z.number().int()).optional(),
+            tags: z.array(z.number().int()).optional(),
+            featured_media: z.number().int().optional(),
+            date: z.string().optional(),
+            comment_status: z.enum(["open", "closed"]).optional(),
+            ping_status: z.enum(["open", "closed"]).optional(),
+            sticky: z.boolean().optional(),
+            author: z.number().int().optional(),
+            meta: z.record(z.string(), z.unknown()).optional(),
+        },
+        annotations: { openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...data } = input;
+            return wp.posts.update(id, data);
+        },
+    },
+    {
+        name: "wp_delete_post",
+        title: "Delete a post",
+        description: "Move a post to trash, or permanently delete with `force=true`. " +
+            "Force-delete is irreversible.",
+        inputSchema: {
+            id: z.number().int().positive(),
+            force: z
+                .boolean()
+                .optional()
+                .describe("Permanently delete (skip trash). Default false."),
+        },
+        annotations: { destructiveHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, force = false } = input;
+            return wp.posts.remove(id, force);
+        },
+    },
+    {
+        name: "wp_get_post_revisions",
+        title: "List post revisions",
+        description: "List revisions of a given post (audit trail).",
+        inputSchema: {
+            id: z.number().int().positive(),
+            per_page: z.number().int().min(1).max(100).optional(),
+            _fields: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: async (input) => {
+            const { id, ...rest } = input;
+            const result = await wp.posts.revisions(id, rest);
+            return { revisions: result.data, total: result.total };
+        },
+    },
+];
+//# sourceMappingURL=posts.js.map

package/dist/tools/seo.d.ts

@@ -0,0 +1,4 @@
+import { WordPressClient } from "../wordpress-client.js";
+import type { ToolDef } from "../types.js";
+export declare const seoTools: (wp: WordPressClient) => ToolDef[];
+//# sourceMappingURL=seo.d.ts.map