@noleemits/vision-builder-control-mcp 4.114.0 → 4.119.0

package/index.js

@@ -111,7 +111,7 @@ process.on('SIGINT', () => {
 // CONFIG
 // ================================================================
 
-const VERSION = '4.114.0';
+const VERSION = '4.119.0';
 const MIN_PLUGIN_VERSION = '4.13.0'; // Minimum WP plugin version required by this MCP server
 
 // v4.110.0: shared styling philosophy appended to every build/style tool so the
@@ -1742,6 +1742,7 @@ async function apiCall(endpoint, method = 'GET', body = null) {
                 'Content-Type': 'application/json',
                 'Accept': 'application/json',
                 'User-Agent': `Vision-Builder-Control/${VERSION}`,
+                'Connection': 'close',
             },
             signal: controller.signal,
         };
@@ -1907,6 +1908,17 @@ function getToolDefinitions() {
             description: 'Probe the connected WordPress site for the actual plugin version + every REST route the plugin has registered. Use when a tool returns "Backend route missing on this site" / "No route was found" — this confirms the site is running an older plugin version than the MCP server expects. Output includes a mismatch report comparing MCP-required routes against what the backend actually exposes, so callers can decide whether to update the site plugin. v4.46.0+.',
             inputSchema: { type: 'object', properties: {} }
         },
+        {
+            name: 'search_tools',
+            description: 'Search available MCP tools by keyword. Returns matching tool names and one-line descriptions. Call this early in a session to discover which tools cover a given task — e.g. "css classes", "page", "template", "seo", "image", "nav". Pass an empty string to list every tool.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Keyword(s) to match against tool names and descriptions. Empty string returns all tools.' }
+                },
+                required: ['query']
+            }
+        },
         {
             name: 'get_design_tokens',
             description: 'Get all design tokens (colors, typography, spacing, URLs, buttons, globals_map). Tokens are cached for 5 minutes.',
@@ -2464,7 +2476,7 @@ function getToolDefinitions() {
         },
         {
             name: 'create_post',
-            description: 'Create a WordPress post, page, or CPT. Supports content, excerpt, taxonomies, featured image, parent linking (by slug or ID), an explicit publish date (for migrations), Elementor setup, and initial RankMath SEO data.',
+            description: 'Create a WordPress post, page, or CPT. Supports content, excerpt, taxonomies, featured image, parent linking (by slug or ID), an explicit publish date (for migrations), Elementor setup, and initial RankMath SEO data. Accepts author (ID, login, slug, or email; requires edit_others_posts).',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -2473,9 +2485,10 @@ function getToolDefinitions() {
                     content: { type: 'string', description: 'Post content (block HTML or plain text)' },
                     excerpt: { type: 'string', description: 'Post excerpt' },
                     status: { type: 'string', enum: ['draft', 'publish', 'private', 'pending'], description: 'Post status (default: draft)' },
+                    slug: { type: 'string', description: 'URL slug (auto-generated if omitted)' },
+                    author: { type: ['string', 'number'], description: 'Author to assign: user ID, login, slug, or email. Requires edit_others_posts.' },
                     date: { type: 'string', description: 'Explicit publish date in site-local time, "YYYY-MM-DD HH:MM:SS" (or any strtotime-parseable string). Use to PRESERVE original dates when migrating posts — omit and the post gets the current date.' },
                     date_gmt: { type: 'string', description: 'Optional explicit UTC date. If omitted, derived from `date` via the site timezone.' },
-                    slug: { type: 'string', description: 'URL slug (auto-generated if omitted)' },
                     parent: { type: 'number', description: 'Parent post ID (for hierarchical types). Use this OR parent_slug.' },
                     parent_slug: { type: 'string', description: 'Parent slug — looked up against the same post_type. Saves a follow-up update_post call.' },
                     taxonomies: { type: 'object', description: 'Object: {"category": [1,2], "post_tag": ["seo","health"]}' },
@@ -2490,7 +2503,7 @@ function getToolDefinitions() {
         },
         {
             name: 'update_post',
-            description: 'Update any field on a WordPress post/page. Only provided fields are changed. Supports title, content, status, slug, excerpt, parent (ID or slug), taxonomies, featured image (ID or basename), and RankMath SEO. Pass preserve_modified_date=true to keep the original last-modified date.',
+            description: 'Update any field on a WordPress post/page. Only provided fields are changed. Supports title, content, status, slug, excerpt, parent (ID or slug), taxonomies, featured image (ID or basename), and RankMath SEO. Pass preserve_modified_date=true to keep the original last-modified date. Accepts author (ID, login, slug, or email; requires edit_others_posts).',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -2500,6 +2513,7 @@ function getToolDefinitions() {
                     excerpt: { type: 'string' },
                     status: { type: 'string', enum: ['draft', 'publish', 'private', 'pending', 'trash'] },
                     slug: { type: 'string' },
+                    author: { type: ['string', 'number'], description: 'Author to assign: user ID, login, slug, or email. Requires edit_others_posts.' },
                     parent: { type: 'number', description: 'Parent post/page ID (for hierarchical types like pages). Changes URL structure.' },
                     parent_slug: { type: 'string', description: 'Parent slug — looked up against this post\'s post_type. Use instead of parent when you don\'t know the parent ID.' },
                     taxonomies: { type: 'object', description: '{"category": [1,2]}' },
@@ -2536,6 +2550,46 @@ function getToolDefinitions() {
                 required: ['slug']
             }
         },
+        {
+            name: 'list_users',
+            description: 'List WordPress users (authors/editors/etc). Returns id, login, slug, display_name, email, roles, and published post_count. Use to discover an author ID/login before assigning posts with create_post/update_post/set_post_author/reassign_author. Requires the list_users capability.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    role: { type: 'string', description: 'Filter by role slug (e.g. "author", "editor", "administrator").' },
+                    search: { type: 'string', description: 'Substring match on login, name, or email.' },
+                    has_posts: { type: 'boolean', description: 'If true, only users with at least one published post.' },
+                    per_page: { type: 'number', description: 'Max results (default 100, cap 200).' }
+                }
+            }
+        },
+        {
+            name: 'set_post_author',
+            description: 'Assign one author to a specific list of posts (bulk). Pass post_ids and an author (ID, login, slug, or email). Returns which posts were updated vs skipped. Requires edit_others_posts.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    post_ids: { type: 'array', items: { type: 'number' }, description: 'Post IDs to reassign.' },
+                    author: { type: ['string', 'number'], description: 'Target author: ID, login, slug, or email.' }
+                },
+                required: ['post_ids', 'author']
+            }
+        },
+        {
+            name: 'reassign_author',
+            description: 'Reassign ALL posts from one author to another (e.g. offboarding a writer). from/to accept ID, login, slug, or email. Optionally filter by post_type and status. Pass dry_run:true first to see how many posts would move without changing anything. Requires edit_others_posts.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    from: { type: ['string', 'number'], description: 'Source author (ID, login, slug, or email).' },
+                    to: { type: ['string', 'number'], description: 'Destination author (ID, login, slug, or email).' },
+                    post_type: { type: 'string', description: 'Limit to one post type (default: all).' },
+                    status: { type: 'array', items: { type: 'string' }, description: 'Statuses to include (default: publish,draft,pending,private,future).' },
+                    dry_run: { type: 'boolean', description: 'If true, only count + list the post IDs that would move. ALWAYS run this first on a large reassignment.' }
+                },
+                required: ['from', 'to']
+            }
+        },
         {
             name: 'change_post_type',
             description: 'Migrate a WordPress post to a different post type IN PLACE — preserves post ID, post_meta (SEO, featured image, custom fields), comments, attachments, post_date, and any taxonomy terms registered on both types. Atomic operation (single DB write to the post_type column, no save_post re-fire). Optionally rewrites internal links across all post_content and creates a RankMath 301 redirect from the old permalink. Use this instead of create_post + delete_post when moving a page to a CPT — it is faster, lossless, and keeps the URL history.',
@@ -3633,6 +3687,31 @@ function getToolDefinitions() {
                 required: ['post_id', 'fields']
             }
         },
+        {
+            name: 'get_post_meta',
+            description: 'Read RAW WordPress post meta for any post (not ACF-specific — get_acf_fields cannot see plain meta written by themes, page builders, or generators like Mosaic). Returns stored values including HTML. Distinguishes missing keys (in `missing`) from present-but-empty (value === ""). Omit `keys` to return all non-protected meta.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    post_id: { type: 'number', description: 'WordPress post ID' },
+                    keys: { type: 'array', items: { type: 'string' }, description: 'Optional list of meta keys. Omit to return all non-protected meta.' }
+                },
+                required: ['post_id']
+            }
+        },
+        {
+            name: 'update_post_meta',
+            description: 'Write RAW WordPress post meta (HTML-safe, no wpautop mangling). Defaults to dry_run=true — set dry_run=false to apply. Protected meta (keys starting with "_") is skipped. Use for seeding/correcting plain custom fields. Note: update returns "unchanged_or_failed" when the new value equals the stored value.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    post_id: { type: 'number', description: 'WordPress post ID' },
+                    meta: { type: 'object', description: 'Object of { metaKey: value }. Values stored raw (HTML preserved).' },
+                    dry_run: { type: 'boolean', description: 'Default true. Set false to write.' }
+                },
+                required: ['post_id', 'meta']
+            }
+        },
         {
             name: 'create_acf_field_group',
             description: 'Create a new ACF field group with fields and post type assignments. Supports field types: text, textarea, wysiwyg, number, url, image, select, true_false, repeater, group.',
@@ -3717,6 +3796,48 @@ function getToolDefinitions() {
                 required: ['source_template_id', 'title']
             }
         },
+        {
+            name: 'duplicate_post',
+            description: 'Duplicate any post into a new post in one call. Can change post_type (e.g. clone a CPT post into a standalone page). Copies _elementor_data with regenerated element IDs, the WP page template, selected post meta, and RankMath SEO by default. Returns the new ID + preview URL. NOTE: this copies structure + meta but does NOT resolve dynamic tags — a clone of a template-driven CPT post still renders via dynamic tags unless you also flatten_dynamic_tags or update_post_meta the clone.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source_id: { type: 'number', description: 'Post ID to duplicate' },
+                    new_title: { type: 'string', description: 'Title for the copy (default: "<source> (copy)")' },
+                    new_slug: { type: 'string', description: 'Optional slug (auto from title if omitted)' },
+                    status: { type: 'string', enum: ['publish', 'draft', 'private', 'pending'], description: 'Default draft' },
+                    target_post_type: { type: 'string', description: 'Optional — clone into a different post type, e.g. "page". Default: same as source.' },
+                    include: {
+                        type: 'object',
+                        description: 'What to copy. Defaults all true. meta can be true (all non-protected) or an array of specific keys. Set seo:false to skip rank_math_* when copying all meta.',
+                        properties: {
+                            elementor_data: { type: 'boolean' },
+                            page_template: { type: 'boolean' },
+                            meta: {},
+                            seo: { type: 'boolean' }
+                        }
+                    }
+                },
+                required: ['source_id']
+            }
+        },
+        {
+            name: 'flatten_dynamic_tags',
+            description: 'Resolve Elementor dynamic tags on a post to their literal rendered values and write the result back (in place, or to a different target). Resolves ANY bound tag via Elementor itself — honors fallback/after exactly as the front end. meta_context_id lets you bake post X\'s content onto a generic clone. Action tags (popup) and functional widgets (jet-form-builder-form) are skipped by default — extend via skip_tags / skip_widgets. Defaults dry_run=true: review the per-binding report, then set dry_run=false. This is the one-shot de-dynamification primitive for converting template-driven CPT posts into self-contained static pages.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source_id: { type: 'number', description: 'Post whose dynamic tags to resolve (path param)' },
+                    target_id: { type: 'number', description: 'Write resolved data here. Omit = in place (= source).' },
+                    meta_context_id: { type: 'number', description: 'Resolve post-aware tags against THIS post\'s context/meta. Omit = source. CRITICAL when source is a shared template (which has no per-item meta): set this to the specific CPT post whose content you want baked, or every tag resolves to its fallback.' },
+                    strip_bindings: { type: 'boolean', description: 'Remove __dynamic__ entries after inlining. Default true.' },
+                    dry_run: { type: 'boolean', description: 'Default true. Set false to write.' },
+                    skip_tags: { type: 'array', items: { type: 'string' }, description: 'Extra tag names to leave untouched (popup always skipped).' },
+                    skip_widgets: { type: 'array', items: { type: 'string' }, description: 'Extra widget types to leave untouched (jet-form-builder-form always skipped).' }
+                },
+                required: ['source_id']
+            }
+        },
         {
             name: 'create_template',
             description: 'Create a BLANK Theme Builder template in one call — then fill it with append_section / add_element. Atomically sets post_type=elementor_library, the elementor_library_type TAXONOMY TERM (required for loop context — setting only the meta silently fails for loop-item), the _elementor_template_type meta, and builder edit-mode. Use this instead of a raw wp/v2/elementor_library POST (which omits the taxonomy term and silently produces a loop template with no post context). For a template BASED ON an existing design, use clone_template instead. v4.111.0.',
@@ -5222,6 +5343,42 @@ async function handleToolCall(name, args) {
         return ok(out);
     }
 
+    case 'list_users': {
+        const params = new URLSearchParams();
+        if (args.role) params.set('role', args.role);
+        if (args.search) params.set('search', args.search);
+        if (args.has_posts) params.set('has_posts', '1');
+        if (args.per_page) params.set('per_page', args.per_page);
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        const r = await apiCall(`/users${qs}`);
+        if (!r.success) return ok(`Failed: ${r.message || 'Unknown error'}`);
+        let out = `${r.total} users\n${'─'.repeat(50)}\n`;
+        r.users.forEach(u => {
+            out += `[${u.id}] ${u.display_name} (${u.login})\n`;
+            out += `    Roles: ${u.roles.join(', ') || 'none'} | Posts: ${u.post_count} | ${u.email}\n`;
+        });
+        return ok(out);
+    }
+
+    case 'set_post_author': {
+        const r = await apiCall('/posts/set-author', 'POST', { post_ids: args.post_ids, author: args.author });
+        if (!r.success) return ok(`Failed: ${r.message || 'Unknown error'}`);
+        let out = `Set author → ${r.author} (#${r.author_id})\nUpdated ${r.count}: ${r.updated.join(', ')}`;
+        if (r.skipped.length) out += `\nSkipped ${r.skipped.length}: ${r.skipped.map(s => `${s.id} (${s.reason})`).join(', ')}`;
+        return ok(out);
+    }
+
+    case 'reassign_author': {
+        const body = { from: args.from, to: args.to };
+        if (args.post_type) body.post_type = args.post_type;
+        if (args.status) body.status = args.status;
+        if (args.dry_run) body.dry_run = true;
+        const r = await apiCall('/users/reassign-author', 'POST', body);
+        if (!r.success) return ok(`Failed: ${r.message || 'Unknown error'}`);
+        if (r.dry_run) return ok(`DRY RUN: ${r.would_reassign} posts would move from #${r.from_id} → #${r.to_id}.\nIDs: ${r.post_ids.join(', ')}`);
+        return ok(`Reassigned ${r.count} posts: ${r.from} (#${r.from_id}) → ${r.to} (#${r.to_id})`);
+    }
+
     case 'get_post': {
         const r = await apiCall(`/posts/${args.post_id}`);
         if (!r.success) return ok(`Failed: ${r.message || 'Not found'}`);
@@ -5254,7 +5411,7 @@ async function handleToolCall(name, args) {
     case 'create_post': {
         const body = { title: args.title };
         const passthrough = ['post_type', 'content', 'excerpt', 'status', 'slug',
-            'parent', 'parent_slug', 'taxonomies', 'featured_image_id',
+            'author', 'parent', 'parent_slug', 'taxonomies', 'featured_image_id',
             'featured_image_basename', 'elementor', 'seo', 'dedupe_by_title',
             'date', 'date_gmt'];
         for (const k of passthrough) if (args[k] !== undefined) body[k] = args[k];
@@ -7020,6 +7177,39 @@ async function handleToolCall(name, args) {
         return ok(out);
     }
 
+    case 'get_post_meta': {
+        let ep = `/post-meta?post_id=${args.post_id}`;
+        if (Array.isArray(args.keys) && args.keys.length) {
+            ep += `&keys=${encodeURIComponent(args.keys.join(','))}`;
+        }
+        const r = await apiCall(ep);
+        if (r.code || r.error) return ok(`Failed: ${r.message || r.error}`);
+        let out = `=== POST META: ${r.post_title} (ID:${r.post_id}) ===\n`;
+        const keys = Object.keys(r.meta || {});
+        if (!keys.length) {
+            out += 'No meta found.\n';
+        } else {
+            keys.forEach(k => {
+                const m = r.meta[k];
+                const val = typeof m.value === 'object' ? JSON.stringify(m.value) : (m.value === '' ? '(empty)' : m.value);
+                out += `\n  ${k}${m.count > 1 ? ` [×${m.count}]` : ''}: ${val}\n`;
+            });
+        }
+        if (r.missing && r.missing.length) out += `\nMISSING (not present): ${r.missing.join(', ')}\n`;
+        return ok(out);
+    }
+
+    case 'update_post_meta': {
+        const body = { post_id: args.post_id, meta: args.meta };
+        if (typeof args.dry_run === 'boolean') body.dry_run = args.dry_run;
+        const r = await apiCall('/post-meta', 'POST', body);
+        if (r.code || r.error) return ok(`Failed: ${r.message || r.error}`);
+        let out = `${r.dry_run ? 'DRY RUN' : 'WROTE'} — ${r.updated} key(s) on "${r.post_title}" (ID:${r.post_id})\n`;
+        (r.results || []).forEach(x => { out += `  ${x.key}: ${x.status}\n`; });
+        out += `\n${r.note}\n`;
+        return ok(out);
+    }
+
     case 'create_acf_field_group': {
         const body = { title: args.title, fields: args.fields };
         if (args.post_types) body.post_types = args.post_types;
@@ -7154,6 +7344,42 @@ async function handleToolCall(name, args) {
         return ok(msg);
     }
 
+    case 'duplicate_post': {
+        if (!args.source_id) return ok('Failed: source_id is required.');
+        const body = { source_id: args.source_id };
+        if (args.new_title) body.new_title = args.new_title;
+        if (args.new_slug) body.new_slug = args.new_slug;
+        if (args.status) body.status = args.status;
+        if (args.target_post_type) body.target_post_type = args.target_post_type;
+        if (args.include) body.include = args.include;
+        const r = await apiCall('/posts/duplicate', 'POST', body);
+        if (r.code || r.error) return ok(`Failed: ${r.message || r.error}`);
+        let out = `Duplicated post ${r.source_id} (${r.source_type}) → ${r.new_id} (${r.new_post_type}, ${r.status})\n`;
+        out += `Sections: ${r.sections} | Meta copied: ${r.meta_copied.length}\n`;
+        out += `Preview: ${r.preview_url}\nEdit: ${r.edit_url}\n`;
+        return ok(out);
+    }
+
+    case 'flatten_dynamic_tags': {
+        if (!args.source_id) return ok('Failed: source_id is required.');
+        const body = {};
+        if (args.target_id) body.target_id = args.target_id;
+        if (args.meta_context_id) body.meta_context_id = args.meta_context_id;
+        if (typeof args.strip_bindings === 'boolean') body.strip_bindings = args.strip_bindings;
+        if (typeof args.dry_run === 'boolean') body.dry_run = args.dry_run;
+        if (Array.isArray(args.skip_tags)) body.skip_tags = args.skip_tags;
+        if (Array.isArray(args.skip_widgets)) body.skip_widgets = args.skip_widgets;
+        const r = await apiCall(`/pages/${args.source_id}/flatten-dynamic-tags`, 'POST', body);
+        if (r.code || r.error) return ok(`Failed: ${r.message || r.error}`);
+        let out = `${r.dry_run ? 'DRY RUN' : 'FLATTENED'} — ${r.resolved} binding(s) | source ${r.source_id} → target ${r.target_id} | ctx ${r.meta_context_id}\n`;
+        out += `Skipped tags: ${r.skipped_tags.join(', ')} | Skipped widgets: ${r.skipped_widgets.join(', ')}\n\n`;
+        (r.report || []).forEach(x => {
+            out += `  [${x.action}] ${x.id || ''} ${x.field ? `.${x.field}` : ''} ${x.tag ? `(${x.tag})` : ''}${x.preview ? ` → ${x.preview}` : ''}\n`;
+        });
+        out += `\n${r.note}\n`;
+        return ok(out);
+    }
+
     case 'create_template': {
         if (!args.type || !args.title) {
             return ok('Failed: type and title are required.');
@@ -8268,6 +8494,21 @@ async function handleToolCall(name, args) {
         return ok(msg);
     }
 
+    case 'search_tools': {
+        const q = (args.query || '').toLowerCase().trim();
+        const all = getToolDefinitions();
+        const matches = q
+            ? all.filter(t => t.name.includes(q) || t.description.toLowerCase().includes(q))
+            : all;
+        if (!matches.length) return ok(`No tools match "${args.query}". Try a broader term.`);
+        const lines = matches.map(t => {
+            const firstSentence = t.description.split(/[.\n]/)[0].trim();
+            return `${t.name} — ${firstSentence}`;
+        });
+        const header = q ? `${matches.length} tool(s) matched "${args.query}"` : `${matches.length} tools available`;
+        return ok(`${header}\n\n${lines.join('\n')}`);
+    }
+
     default:
         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noleemits/vision-builder-control-mcp",
-  "version": "4.114.0",
+  "version": "4.119.0",
   "description": "Vision Builder Control MCP server - design token-driven page builder tools for WordPress/Elementor websites",
   "type": "module",
   "main": "index.js",