claude-plugin-wordpress-manager 2.4.0 → 2.9.0

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

@@ -0,0 +1,196 @@
+import { hasGoogleApiKey, getGoogleApiKey } from '../wordpress.js';
+import axios from 'axios';
+import { z } from 'zod';
+// ── Zod Schemas ─────────────────────────────────────────────────
+const cwvAnalyzeUrlSchema = z.object({
+    url: z.string().describe('URL to analyze'),
+    strategy: z.enum(['mobile', 'desktop']).optional().default('mobile')
+        .describe('Analysis strategy (default: mobile)'),
+    categories: z.array(z.enum(['performance', 'accessibility', 'best-practices', 'seo'])).optional()
+        .describe('Lighthouse categories to include (default: performance only)'),
+}).strict();
+const cwvBatchAnalyzeSchema = z.object({
+    urls: z.array(z.string()).describe('Array of URLs to analyze (max 10)'),
+    strategy: z.enum(['mobile', 'desktop']).optional().default('mobile'),
+}).strict();
+const cwvGetFieldDataSchema = z.object({
+    url: z.string().optional().describe('Specific URL for field data (omit for origin-level data)'),
+    origin: z.string().optional().describe('Origin URL (e.g., https://mysite.com)'),
+    form_factor: z.enum(['PHONE', 'DESKTOP', 'TABLET', 'ALL_FORM_FACTORS']).optional().default('ALL_FORM_FACTORS'),
+}).strict();
+const cwvComparePagesSchema = z.object({
+    urls: z.array(z.string()).describe('URLs to compare (2-5)'),
+    strategy: z.enum(['mobile', 'desktop']).optional().default('mobile'),
+}).strict();
+// ── Tool Definitions ────────────────────────────────────────────
+export const cwvTools = [
+    {
+        name: "cwv_analyze_url",
+        description: "Analyzes Core Web Vitals for a URL via PageSpeed Insights (LCP, INP, CLS, FCP, TTFB)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to analyze" },
+                strategy: { type: "string", enum: ["mobile", "desktop"], description: "Strategy (default: mobile)" },
+                categories: { type: "array", items: { type: "string", enum: ["performance", "accessibility", "best-practices", "seo"] }, description: "Categories to include" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "cwv_batch_analyze",
+        description: "Analyzes Core Web Vitals for multiple URLs (max 10) via PageSpeed Insights",
+        inputSchema: {
+            type: "object",
+            properties: {
+                urls: { type: "array", items: { type: "string" }, description: "URLs to analyze (max 10)" },
+                strategy: { type: "string", enum: ["mobile", "desktop"], description: "Strategy (default: mobile)" },
+            },
+            required: ["urls"],
+        },
+    },
+    {
+        name: "cwv_get_field_data",
+        description: "Gets real-user CWV field data from Chrome UX Report (28-day aggregate)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "Specific URL (omit for origin-level)" },
+                origin: { type: "string", description: "Origin URL (e.g., https://mysite.com)" },
+                form_factor: { type: "string", enum: ["PHONE", "DESKTOP", "TABLET", "ALL_FORM_FACTORS"], description: "Form factor (default: ALL)" },
+            },
+        },
+    },
+    {
+        name: "cwv_compare_pages",
+        description: "Compares Core Web Vitals across multiple pages and ranks optimization priority",
+        inputSchema: {
+            type: "object",
+            properties: {
+                urls: { type: "array", items: { type: "string" }, description: "URLs to compare (2-5)" },
+                strategy: { type: "string", enum: ["mobile", "desktop"], description: "Strategy (default: mobile)" },
+            },
+            required: ["urls"],
+        },
+    },
+];
+// ── Handlers ────────────────────────────────────────────────────
+const PSI_BASE = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
+const CRUX_BASE = 'https://chromeuxreport.googleapis.com/v1/records:queryRecord';
+function extractCWV(lighthouse) {
+    const audits = lighthouse?.audits || {};
+    return {
+        lcp: audits['largest-contentful-paint']?.numericValue,
+        fcp: audits['first-contentful-paint']?.numericValue,
+        cls: audits['cumulative-layout-shift']?.numericValue,
+        inp: audits['interaction-to-next-paint']?.numericValue,
+        ttfb: audits['server-response-time']?.numericValue,
+        performance_score: lighthouse?.categories?.performance?.score,
+    };
+}
+export const cwvHandlers = {
+    cwv_analyze_url: async (params) => {
+        if (!hasGoogleApiKey()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Google API key not configured. Add google_api_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { url, strategy, categories } = params;
+            const apiKey = getGoogleApiKey();
+            const queryParams = { url, key: apiKey, strategy: strategy || 'mobile' };
+            queryParams.category = categories && categories.length > 0 ? categories : ['performance'];
+            const response = await axios.get(PSI_BASE, { params: queryParams, timeout: 60000 });
+            const cwv = extractCWV(response.data.lighthouseResult);
+            const result = { url, strategy: strategy || 'mobile', cwv, fieldData: response.data.loadingExperience || null };
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error analyzing URL: ${errorMessage}` }] } };
+        }
+    },
+    cwv_batch_analyze: async (params) => {
+        if (!hasGoogleApiKey()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Google API key not configured. Add google_api_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { urls, strategy } = params;
+            const limitedUrls = urls.slice(0, 10);
+            const apiKey = getGoogleApiKey();
+            const results = [];
+            for (const url of limitedUrls) {
+                try {
+                    const response = await axios.get(PSI_BASE, {
+                        params: { url, key: apiKey, strategy: strategy || 'mobile', category: 'performance' },
+                        timeout: 60000,
+                    });
+                    const cwv = extractCWV(response.data.lighthouseResult);
+                    results.push({ url, cwv, status: 'ok' });
+                }
+                catch (err) {
+                    results.push({ url, status: 'error', error: err.response?.data?.error?.message || err.message });
+                }
+            }
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error in batch analysis: ${error.message}` }] } };
+        }
+    },
+    cwv_get_field_data: async (params) => {
+        if (!hasGoogleApiKey()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Google API key not configured. Add google_api_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { url, origin, form_factor } = params;
+            const apiKey = getGoogleApiKey();
+            const requestBody = {};
+            if (url)
+                requestBody.url = url;
+            else if (origin)
+                requestBody.origin = origin;
+            else
+                return { toolResult: { isError: true, content: [{ type: "text", text: "Provide either url or origin parameter." }] } };
+            if (form_factor && form_factor !== 'ALL_FORM_FACTORS')
+                requestBody.formFactor = form_factor;
+            const response = await axios.post(CRUX_BASE, requestBody, { params: { key: apiKey }, timeout: 30000 });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting CrUX data: ${errorMessage}` }] } };
+        }
+    },
+    cwv_compare_pages: async (params) => {
+        if (!hasGoogleApiKey()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Google API key not configured. Add google_api_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { urls, strategy } = params;
+            const limitedUrls = urls.slice(0, 5);
+            const apiKey = getGoogleApiKey();
+            const results = [];
+            for (const url of limitedUrls) {
+                try {
+                    const response = await axios.get(PSI_BASE, {
+                        params: { url, key: apiKey, strategy: strategy || 'mobile', category: 'performance' },
+                        timeout: 60000,
+                    });
+                    const cwv = extractCWV(response.data.lighthouseResult);
+                    results.push({ url, cwv });
+                }
+                catch (err) {
+                    results.push({ url, cwv: null, error: err.message });
+                }
+            }
+            // Rank by worst LCP
+            const ranked = results
+                .filter(r => r.cwv)
+                .sort((a, b) => (b.cwv.lcp || 0) - (a.cwv.lcp || 0))
+                .map((r, i) => ({ ...r, priority: i + 1 }));
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ comparison: ranked, worst_first: true }, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error comparing pages: ${error.message}` }] } };
+        }
+    },
+};

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

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const ga4Tools: Tool[];
+export declare const ga4Handlers: Record<string, Function>;

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

@@ -0,0 +1,323 @@
+import { hasGA4, getGA4Auth, getGA4PropertyId } from '../wordpress.js';
+import { google } from 'googleapis';
+import { z } from 'zod';
+// ── Zod Schemas ─────────────────────────────────────────────────
+const ga4RunReportSchema = z.object({
+    dimensions: z.array(z.string()).describe('GA4 dimensions (e.g. pagePath, sessionSource, country)'),
+    metrics: z.array(z.string()).describe('GA4 metrics (e.g. screenPageViews, activeUsers, sessions)'),
+    start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+    end_date: z.string().describe('End date in YYYY-MM-DD format'),
+    limit: z.number().optional().default(100)
+        .describe('Maximum number of rows to return (default 100)'),
+}).strict();
+const ga4GetRealtimeSchema = z.object({
+    metrics: z.array(z.string()).optional().default(['activeUsers'])
+        .describe('Real-time metrics (default: activeUsers)'),
+    dimensions: z.array(z.string()).optional()
+        .describe('Real-time dimensions (optional, e.g. unifiedScreenName)'),
+}).strict();
+const ga4TopPagesSchema = z.object({
+    start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+    end_date: z.string().describe('End date in YYYY-MM-DD format'),
+    limit: z.number().optional().default(25)
+        .describe('Number of top pages to return (default 25)'),
+}).strict();
+const ga4TrafficSourcesSchema = z.object({
+    start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+    end_date: z.string().describe('End date in YYYY-MM-DD format'),
+    limit: z.number().optional().default(25)
+        .describe('Number of traffic sources to return (default 25)'),
+}).strict();
+const ga4UserDemographicsSchema = z.object({
+    start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+    end_date: z.string().describe('End date in YYYY-MM-DD format'),
+    breakdown: z.enum(['country', 'deviceCategory', 'browser']).optional().default('country')
+        .describe('Breakdown dimension (default: country)'),
+    limit: z.number().optional().default(25)
+        .describe('Number of rows to return (default 25)'),
+}).strict();
+const ga4ConversionEventsSchema = z.object({
+    start_date: z.string().describe('Start date in YYYY-MM-DD format'),
+    end_date: z.string().describe('End date in YYYY-MM-DD format'),
+    limit: z.number().optional().default(25)
+        .describe('Number of conversion events to return (default 25)'),
+}).strict();
+// ── Tool Definitions ────────────────────────────────────────────
+export const ga4Tools = [
+    {
+        name: "ga4_run_report",
+        description: "Runs a custom GA4 report with specified dimensions, metrics, and date range",
+        inputSchema: {
+            type: "object",
+            properties: {
+                dimensions: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "GA4 dimensions (e.g. pagePath, sessionSource, country)",
+                },
+                metrics: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "GA4 metrics (e.g. screenPageViews, activeUsers, sessions)",
+                },
+                start_date: { type: "string", description: "Start date in YYYY-MM-DD format" },
+                end_date: { type: "string", description: "End date in YYYY-MM-DD format" },
+                limit: { type: "number", description: "Maximum number of rows to return (default 100)" },
+            },
+            required: ["dimensions", "metrics", "start_date", "end_date"],
+        },
+    },
+    {
+        name: "ga4_get_realtime",
+        description: "Gets real-time active users and metrics from GA4",
+        inputSchema: {
+            type: "object",
+            properties: {
+                metrics: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Real-time metrics (default: activeUsers)",
+                },
+                dimensions: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Real-time dimensions (optional, e.g. unifiedScreenName)",
+                },
+            },
+        },
+    },
+    {
+        name: "ga4_top_pages",
+        description: "Gets top pages by pageviews from GA4 (convenience shortcut for ga4_run_report)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_date: { type: "string", description: "Start date in YYYY-MM-DD format" },
+                end_date: { type: "string", description: "End date in YYYY-MM-DD format" },
+                limit: { type: "number", description: "Number of top pages to return (default 25)" },
+            },
+            required: ["start_date", "end_date"],
+        },
+    },
+    {
+        name: "ga4_traffic_sources",
+        description: "Gets traffic breakdown by source/medium from GA4 (convenience shortcut for ga4_run_report)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_date: { type: "string", description: "Start date in YYYY-MM-DD format" },
+                end_date: { type: "string", description: "End date in YYYY-MM-DD format" },
+                limit: { type: "number", description: "Number of traffic sources to return (default 25)" },
+            },
+            required: ["start_date", "end_date"],
+        },
+    },
+    {
+        name: "ga4_user_demographics",
+        description: "Gets user demographics breakdown (country, device, or browser) from GA4 (convenience shortcut)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_date: { type: "string", description: "Start date in YYYY-MM-DD format" },
+                end_date: { type: "string", description: "End date in YYYY-MM-DD format" },
+                breakdown: {
+                    type: "string",
+                    enum: ["country", "deviceCategory", "browser"],
+                    description: "Breakdown dimension (default: country)",
+                },
+                limit: { type: "number", description: "Number of rows to return (default 25)" },
+            },
+            required: ["start_date", "end_date"],
+        },
+    },
+    {
+        name: "ga4_conversion_events",
+        description: "Gets conversion events and rates from GA4 (convenience shortcut for ga4_run_report)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_date: { type: "string", description: "Start date in YYYY-MM-DD format" },
+                end_date: { type: "string", description: "End date in YYYY-MM-DD format" },
+                limit: { type: "number", description: "Number of conversion events to return (default 25)" },
+            },
+            required: ["start_date", "end_date"],
+        },
+    },
+];
+// ── Handlers ────────────────────────────────────────────────────
+export const ga4Handlers = {
+    ga4_run_report: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { dimensions, metrics, start_date, end_date, limit } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const response = await analyticsdata.properties.runReport({
+                property: propertyId,
+                requestBody: {
+                    dateRanges: [{ startDate: start_date, endDate: end_date }],
+                    dimensions: dimensions.map(d => ({ name: d })),
+                    metrics: metrics.map(m => ({ name: m })),
+                    limit: String(limit || 100),
+                },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error running GA4 report: ${errorMessage}` }] } };
+        }
+    },
+    ga4_get_realtime: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { metrics, dimensions } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const requestBody = {
+                metrics: (metrics || ['activeUsers']).map(m => ({ name: m })),
+            };
+            if (dimensions && dimensions.length > 0) {
+                requestBody.dimensions = dimensions.map(d => ({ name: d }));
+            }
+            const response = await analyticsdata.properties.runRealtimeReport({
+                property: propertyId,
+                requestBody,
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting GA4 realtime data: ${errorMessage}` }] } };
+        }
+    },
+    ga4_top_pages: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { start_date, end_date, limit } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const response = await analyticsdata.properties.runReport({
+                property: propertyId,
+                requestBody: {
+                    dateRanges: [{ startDate: start_date, endDate: end_date }],
+                    dimensions: [{ name: 'pagePath' }],
+                    metrics: [
+                        { name: 'screenPageViews' },
+                        { name: 'activeUsers' },
+                        { name: 'averageSessionDuration' },
+                    ],
+                    orderBys: [{ metric: { metricName: 'screenPageViews' }, desc: true }],
+                    limit: String(limit || 25),
+                },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting GA4 top pages: ${errorMessage}` }] } };
+        }
+    },
+    ga4_traffic_sources: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { start_date, end_date, limit } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const response = await analyticsdata.properties.runReport({
+                property: propertyId,
+                requestBody: {
+                    dateRanges: [{ startDate: start_date, endDate: end_date }],
+                    dimensions: [
+                        { name: 'sessionSource' },
+                        { name: 'sessionMedium' },
+                    ],
+                    metrics: [
+                        { name: 'sessions' },
+                        { name: 'activeUsers' },
+                        { name: 'conversions' },
+                    ],
+                    orderBys: [{ metric: { metricName: 'sessions' }, desc: true }],
+                    limit: String(limit || 25),
+                },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting GA4 traffic sources: ${errorMessage}` }] } };
+        }
+    },
+    ga4_user_demographics: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { start_date, end_date, breakdown, limit } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const response = await analyticsdata.properties.runReport({
+                property: propertyId,
+                requestBody: {
+                    dateRanges: [{ startDate: start_date, endDate: end_date }],
+                    dimensions: [{ name: breakdown || 'country' }],
+                    metrics: [
+                        { name: 'activeUsers' },
+                        { name: 'sessions' },
+                        { name: 'screenPageViews' },
+                    ],
+                    orderBys: [{ metric: { metricName: 'activeUsers' }, desc: true }],
+                    limit: String(limit || 25),
+                },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting GA4 user demographics: ${errorMessage}` }] } };
+        }
+    },
+    ga4_conversion_events: async (params) => {
+        if (!hasGA4()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "GA4 not configured. Add ga4_property_id and ga4_service_account_key to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const auth = await getGA4Auth();
+            const propertyId = getGA4PropertyId();
+            const { start_date, end_date, limit } = params;
+            const analyticsdata = google.analyticsdata({ version: 'v1beta', auth });
+            const response = await analyticsdata.properties.runReport({
+                property: propertyId,
+                requestBody: {
+                    dateRanges: [{ startDate: start_date, endDate: end_date }],
+                    dimensions: [{ name: 'eventName' }],
+                    metrics: [
+                        { name: 'eventCount' },
+                        { name: 'conversions' },
+                        { name: 'totalRevenue' },
+                    ],
+                    orderBys: [{ metric: { metricName: 'conversions' }, desc: true }],
+                    limit: String(limit || 25),
+                },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting GA4 conversion events: ${errorMessage}` }] } };
+        }
+    },
+};

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

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const gscTools: Tool[];
+export declare const gscHandlers: Record<string, Function>;