claude-plugin-wordpress-manager 2.9.1 → 2.12.0

package/hooks/hooks.json

@@ -87,6 +87,24 @@
             "prompt": "The agent is about to DELETE a workflow trigger. This will permanently stop all associated automation and notifications (Slack alerts, emails, webhooks) configured for this trigger. Verify the user explicitly requested this deletion and understands that dependent workflows will stop firing."
           }
         ]
+      },
+      {
+        "matcher": "mcp__wp-rest-bridge__tw_delete_tweet",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "The agent is about to DELETE a tweet. This is irreversible. Verify the user explicitly requested this deletion. Respond 'approve' only if intentional."
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__wp-rest-bridge__li_create_article",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "The agent is about to PUBLISH a long-form article on LinkedIn. This will be publicly visible. Verify the user has reviewed the content and explicitly requested publication. Respond 'approve' only if intentional."
+          }
+        ]
       }
     ]
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-plugin-wordpress-manager",
-  "version": "2.9.1",
-  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge (132 tools incl. 30 WooCommerce + 10 Multisite + 4 Webhooks + 7 Mailchimp + 5 Buffer + 6 SendGrid + 8 GSC + 6 GA4 + 4 Plausible + 4 CWV + 3 Slack + 4 Workflows), and WordPress.com MCP with 39 skills, 12 agents, and security hooks. v2.9.0 adds automated workflows (triggers, cron, content lifecycle). WCOP Tier 4+5 complete.",
+  "version": "2.12.0",
+  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge (145 tools incl. 30 WooCommerce + 10 Multisite + 4 Webhooks + 7 Mailchimp + 5 Buffer + 6 SendGrid + 8 GSC + 6 GA4 + 4 Plausible + 4 CWV + 3 Slack + 4 Workflows + 5 LinkedIn + 5 Twitter + 3 Schema), and WordPress.com MCP with 43 skills, 12 agents, and security hooks. v2.12.0 completes WCOP Tier 6+7 with content generation + structured data.",
   "author": {
     "name": "vinmor",
     "email": "morreale.v@gmail.com"
@@ -63,7 +63,10 @@
     "severity-routing",
     "workflows",
     "automation",
-    "cron-triggers"
+    "cron-triggers",
+    "linkedin",
+    "twitter",
+    "direct-social"
   ],
   "repository": {
     "type": "git",

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

@@ -24,6 +24,9 @@ import { plausibleTools, plausibleHandlers } from './plausible.js';
 import { cwvTools, cwvHandlers } from './cwv.js';
 import { slackTools, slackHandlers } from './slack.js';
 import { wcWorkflowTools, wcWorkflowHandlers } from './wc-workflows.js';
+import { linkedinTools, linkedinHandlers } from './linkedin.js';
+import { twitterTools, twitterHandlers } from './twitter.js';
+import { schemaTools, schemaHandlers } from './schema.js';
 // Combine all tools
 export const allTools = [
     ...unifiedContentTools, // 8 tools
@@ -52,6 +55,9 @@ export const allTools = [
     ...cwvTools, // 4 tools
     ...slackTools, // 3 tools
     ...wcWorkflowTools, // 4 tools
+    ...linkedinTools, // 5 tools
+    ...twitterTools, // 5 tools
+    ...schemaTools, // 3 tools
 ];
 // Combine all handlers
 export const toolHandlers = {
@@ -81,4 +87,7 @@ export const toolHandlers = {
     ...cwvHandlers,
     ...slackHandlers,
     ...wcWorkflowHandlers,
+    ...linkedinHandlers,
+    ...twitterHandlers,
+    ...schemaHandlers,
 };

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

@@ -0,0 +1,203 @@
+import { hasLinkedIn, makeLinkedInRequest, getLinkedInPersonUrn } from '../wordpress.js';
+import { z } from 'zod';
+
+// ── Zod Schemas ─────────────────────────────────────────────────
+const liGetProfileSchema = z.object({}).strict();
+
+const liCreatePostSchema = z.object({
+    text: z.string().describe('Post text content'),
+    link_url: z.string().optional().describe('URL to attach as link share'),
+    image_url: z.string().optional().describe('URL of image to attach'),
+    visibility: z.enum(['PUBLIC', 'CONNECTIONS']).optional().default('PUBLIC')
+        .describe('Post visibility (default: PUBLIC)'),
+}).strict();
+
+const liCreateArticleSchema = z.object({
+    title: z.string().describe('Article title'),
+    body_html: z.string().describe('Article body in HTML format'),
+    thumbnail_url: z.string().optional().describe('Thumbnail image URL'),
+}).strict();
+
+const liGetAnalyticsSchema = z.object({
+    post_id: z.string().optional().describe('Specific post URN for analytics (all posts if omitted)'),
+    period: z.enum(['day', 'month']).optional().default('month')
+        .describe('Time granularity (default: month)'),
+}).strict();
+
+const liListPostsSchema = z.object({
+    count: z.number().optional().default(10).describe('Number of posts to return (default 10)'),
+    start: z.number().optional().default(0).describe('Pagination start index'),
+}).strict();
+
+// ── Tool Definitions ────────────────────────────────────────────
+export const linkedinTools = [
+    {
+        name: "li_get_profile",
+        description: "Gets the authenticated LinkedIn user profile (name, headline, vanity URL)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "li_create_post",
+        description: "Creates a LinkedIn feed post (text, optional link or image)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "Post text content" },
+                link_url: { type: "string", description: "URL to attach as link share" },
+                image_url: { type: "string", description: "URL of image to attach" },
+                visibility: { type: "string", enum: ["PUBLIC", "CONNECTIONS"], description: "Post visibility (default: PUBLIC)" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "li_create_article",
+        description: "Publishes a long-form LinkedIn article (blog-to-article)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: { type: "string", description: "Article title" },
+                body_html: { type: "string", description: "Article body in HTML" },
+                thumbnail_url: { type: "string", description: "Thumbnail image URL" },
+            },
+            required: ["title", "body_html"],
+        },
+    },
+    {
+        name: "li_get_analytics",
+        description: "Gets LinkedIn post analytics (impressions, clicks, engagement rate)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                post_id: { type: "string", description: "Specific post URN (all posts if omitted)" },
+                period: { type: "string", enum: ["day", "month"], description: "Time granularity" },
+            },
+        },
+    },
+    {
+        name: "li_list_posts",
+        description: "Lists recent LinkedIn posts by the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                count: { type: "number", description: "Number of posts (default 10)" },
+                start: { type: "number", description: "Pagination start index" },
+            },
+        },
+    },
+];
+
+// ── Handlers ────────────────────────────────────────────────────
+export const linkedinHandlers = {
+    li_get_profile: async (_params) => {
+        if (!hasLinkedIn()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "LinkedIn not configured. Add linkedin_access_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const response = await makeLinkedInRequest('GET', 'userinfo');
+            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 LinkedIn profile: ${errorMessage}` }] } };
+        }
+    },
+
+    li_create_post: async (params) => {
+        if (!hasLinkedIn()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "LinkedIn not configured. Add linkedin_access_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { text, link_url, image_url, visibility } = params;
+            const personUrn = getLinkedInPersonUrn();
+            const payload = {
+                author: personUrn,
+                lifecycleState: 'PUBLISHED',
+                visibility: visibility || 'PUBLIC',
+                commentary: text,
+                distribution: { feedDistribution: 'MAIN_FEED' },
+            };
+            if (link_url) {
+                payload.content = {
+                    article: { source: link_url, title: text.substring(0, 200) },
+                };
+            }
+            const response = await makeLinkedInRequest('POST', 'posts', payload);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ success: true, post_id: response.id || response['x-restli-id'] || 'created' }, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.response?.data || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating LinkedIn post: ${typeof errorMessage === 'string' ? errorMessage : JSON.stringify(errorMessage)}` }] } };
+        }
+    },
+
+    li_create_article: async (params) => {
+        if (!hasLinkedIn()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "LinkedIn not configured. Add linkedin_access_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { title, body_html, thumbnail_url } = params;
+            const personUrn = getLinkedInPersonUrn();
+            const payload = {
+                author: personUrn,
+                lifecycleState: 'PUBLISHED',
+                visibility: 'PUBLIC',
+                commentary: title,
+                content: {
+                    article: {
+                        title,
+                        description: body_html.replace(/<[^>]*>/g, '').substring(0, 256),
+                        source: thumbnail_url || undefined,
+                    },
+                },
+                distribution: { feedDistribution: 'MAIN_FEED' },
+            };
+            const response = await makeLinkedInRequest('POST', 'posts', payload);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ success: true, article_id: response.id || 'created' }, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.response?.data || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating LinkedIn article: ${typeof errorMessage === 'string' ? errorMessage : JSON.stringify(errorMessage)}` }] } };
+        }
+    },
+
+    li_get_analytics: async (params) => {
+        if (!hasLinkedIn()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "LinkedIn not configured. Add linkedin_access_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const personUrn = getLinkedInPersonUrn();
+            const queryParams = {
+                q: 'organizationalEntity',
+                organizationalEntity: personUrn,
+            };
+            if (params.period) queryParams.timeIntervals = `(timeRange:(start:0),timeGranularityType:${params.period.toUpperCase()})`;
+            const response = await makeLinkedInRequest('GET', 'organizationalEntityShareStatistics', 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 LinkedIn analytics: ${errorMessage}` }] } };
+        }
+    },
+
+    li_list_posts: async (params) => {
+        if (!hasLinkedIn()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "LinkedIn not configured. Add linkedin_access_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const personUrn = getLinkedInPersonUrn();
+            const count = params.count || 10;
+            const start = params.start || 0;
+            const response = await makeLinkedInRequest('GET', `posts?author=${encodeURIComponent(personUrn)}&q=author&count=${count}&start=${start}`);
+            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 LinkedIn posts: ${errorMessage}` }] } };
+        }
+    },
+};

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

@@ -0,0 +1,159 @@
+import { makeRequest, getActiveSite } from '../wordpress.js';
+import axios from 'axios';
+import { z } from 'zod';
+
+// ── Zod Schemas ─────────────────────────────────────────────────
+const sdValidateSchema = z.object({
+    url: z.string().optional().describe('URL to validate (fetches and checks JSON-LD)'),
+    markup: z.string().optional().describe('JSON-LD string to validate directly'),
+}).strict().refine(data => data.url || data.markup, { message: 'Either url or markup is required' });
+
+const sdInjectSchema = z.object({
+    post_id: z.number().describe('WordPress post/page ID'),
+    schema_type: z.string().describe('Schema.org type (Article, Product, FAQ, HowTo, LocalBusiness, Event, Organization, BreadcrumbList)'),
+    schema_data: z.record(z.any()).describe('Schema.org properties as key-value pairs'),
+}).strict();
+
+const sdListSchemasSchema = z.object({
+    schema_type: z.string().optional().describe('Filter by specific Schema.org type'),
+}).strict();
+
+// ── Tool Definitions ────────────────────────────────────────────
+export const schemaTools = [
+    {
+        name: "sd_validate",
+        description: "Validates JSON-LD / Schema.org structured data against Google specs",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to fetch and validate JSON-LD from" },
+                markup: { type: "string", description: "JSON-LD string to validate directly" },
+            },
+        },
+    },
+    {
+        name: "sd_inject",
+        description: "Injects or updates JSON-LD structured data in a WordPress post/page",
+        inputSchema: {
+            type: "object",
+            properties: {
+                post_id: { type: "number", description: "WordPress post/page ID" },
+                schema_type: { type: "string", description: "Schema.org type (Article, Product, FAQ, etc.)" },
+                schema_data: { type: "object", description: "Schema.org properties as key-value pairs" },
+            },
+            required: ["post_id", "schema_type", "schema_data"],
+        },
+    },
+    {
+        name: "sd_list_schemas",
+        description: "Lists Schema.org types found across the site with counts",
+        inputSchema: {
+            type: "object",
+            properties: {
+                schema_type: { type: "string", description: "Filter by Schema.org type" },
+            },
+        },
+    },
+];
+
+// ── Handlers ────────────────────────────────────────────────────
+export const schemaHandlers = {
+    sd_validate: async (params) => {
+        try {
+            const { url, markup } = params;
+            if (!url && !markup) {
+                return { toolResult: { isError: true, content: [{ type: "text", text: "Either url or markup parameter is required." }] } };
+            }
+            let jsonLd;
+            if (markup) {
+                try {
+                    jsonLd = JSON.parse(markup);
+                } catch {
+                    return { toolResult: { isError: true, content: [{ type: "text", text: "Invalid JSON in markup parameter." }] } };
+                }
+            } else {
+                // Fetch URL and extract JSON-LD
+                const response = await axios.get(url, { timeout: 15000 });
+                const html = response.data;
+                const jsonLdMatch = html.match(/<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/i);
+                if (!jsonLdMatch) {
+                    return { toolResult: { content: [{ type: "text", text: JSON.stringify({ valid: false, error: "No JSON-LD found on page", url }, null, 2) }] } };
+                }
+                try {
+                    jsonLd = JSON.parse(jsonLdMatch[1]);
+                } catch {
+                    return { toolResult: { content: [{ type: "text", text: JSON.stringify({ valid: false, error: "Invalid JSON-LD on page", url }, null, 2) }] } };
+                }
+            }
+
+            // Basic Schema.org validation
+            const issues = [];
+            const schemas = Array.isArray(jsonLd) ? jsonLd : [jsonLd];
+            for (const schema of schemas) {
+                if (!schema['@context'] || !schema['@context'].includes('schema.org')) {
+                    issues.push('Missing or invalid @context (should include schema.org)');
+                }
+                if (!schema['@type']) {
+                    issues.push('Missing @type');
+                }
+            }
+
+            const result = {
+                valid: issues.length === 0,
+                schemas_found: schemas.length,
+                types: schemas.map(s => s['@type']).filter(Boolean),
+                issues: issues.length > 0 ? issues : undefined,
+                source: url || 'inline markup',
+            };
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] } };
+        } catch (error) {
+            const errorMessage = error.response?.status ? `HTTP ${error.response.status}` : error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error validating schema: ${errorMessage}` }] } };
+        }
+    },
+
+    sd_inject: async (params) => {
+        try {
+            const { post_id, schema_type, schema_data } = params;
+            const jsonLd = JSON.stringify({
+                '@context': 'https://schema.org',
+                '@type': schema_type,
+                ...schema_data,
+            });
+            // Store JSON-LD in post meta via WordPress REST API
+            const response = await makeRequest('POST', `wp/v2/posts/${post_id}`, {
+                meta: { _schema_json_ld: jsonLd },
+            });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ success: true, post_id, schema_type, stored: true }, null, 2) }] } };
+        } catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error injecting schema: ${errorMessage}` }] } };
+        }
+    },
+
+    sd_list_schemas: async (params) => {
+        try {
+            const { schema_type } = params;
+            // Fetch recent posts and check for JSON-LD in meta
+            const posts = await makeRequest('GET', 'wp/v2/posts', { per_page: 100, _fields: 'id,title,meta' });
+            const schemas = {};
+            for (const post of posts) {
+                const meta = post.meta?._schema_json_ld;
+                if (meta) {
+                    try {
+                        const parsed = JSON.parse(meta);
+                        const type = parsed['@type'] || 'Unknown';
+                        if (schema_type && type !== schema_type) continue;
+                        if (!schemas[type]) schemas[type] = { count: 0, posts: [] };
+                        schemas[type].count++;
+                        schemas[type].posts.push({ id: post.id, title: post.title?.rendered });
+                    } catch { /* skip invalid JSON */ }
+                }
+            }
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ total_types: Object.keys(schemas).length, schemas }, null, 2) }] } };
+        } catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing schemas: ${errorMessage}` }] } };
+        }
+    },
+};

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

@@ -0,0 +1,183 @@
+import { hasTwitter, makeTwitterRequest, getTwitterUserId } from '../wordpress.js';
+import { z } from 'zod';
+
+// ── Zod Schemas ─────────────────────────────────────────────────
+const twCreateTweetSchema = z.object({
+    text: z.string().max(280).describe('Tweet text (max 280 characters)'),
+    media_ids: z.array(z.string()).optional().describe('Array of media IDs to attach'),
+    reply_to: z.string().optional().describe('Tweet ID to reply to (for threads)'),
+}).strict();
+
+const twCreateThreadSchema = z.object({
+    tweets: z.array(z.string().max(280)).min(2)
+        .describe('Array of tweet texts (min 2, each max 280 chars)'),
+}).strict();
+
+const twGetMetricsSchema = z.object({
+    tweet_id: z.string().describe('Tweet ID to get metrics for'),
+}).strict();
+
+const twListTweetsSchema = z.object({
+    count: z.number().optional().default(10).describe('Number of tweets (default 10, max 100)'),
+    since: z.string().optional().describe('Only tweets after this ISO 8601 date'),
+}).strict();
+
+const twDeleteTweetSchema = z.object({
+    tweet_id: z.string().describe('Tweet ID to delete'),
+}).strict();
+
+// ── Tool Definitions ────────────────────────────────────────────
+export const twitterTools = [
+    {
+        name: "tw_create_tweet",
+        description: "Publishes a tweet (text, optional media, optional reply-to for threads)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "Tweet text (max 280 characters)" },
+                media_ids: { type: "array", items: { type: "string" }, description: "Media IDs to attach" },
+                reply_to: { type: "string", description: "Tweet ID to reply to" },
+            },
+            required: ["text"],
+        },
+    },
+    {
+        name: "tw_create_thread",
+        description: "Publishes a connected Twitter thread (multiple tweets linked as replies)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tweets: { type: "array", items: { type: "string" }, description: "Array of tweet texts (min 2)" },
+            },
+            required: ["tweets"],
+        },
+    },
+    {
+        name: "tw_get_metrics",
+        description: "Gets tweet metrics (impressions, likes, retweets, replies, quotes)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tweet_id: { type: "string", description: "Tweet ID" },
+            },
+            required: ["tweet_id"],
+        },
+    },
+    {
+        name: "tw_list_tweets",
+        description: "Lists recent tweets by the authenticated user",
+        inputSchema: {
+            type: "object",
+            properties: {
+                count: { type: "number", description: "Number of tweets (default 10)" },
+                since: { type: "string", description: "Only tweets after this ISO 8601 date" },
+            },
+        },
+    },
+    {
+        name: "tw_delete_tweet",
+        description: "Deletes a tweet by ID (irreversible)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tweet_id: { type: "string", description: "Tweet ID to delete" },
+            },
+            required: ["tweet_id"],
+        },
+    },
+];
+
+// ── Handlers ────────────────────────────────────────────────────
+export const twitterHandlers = {
+    tw_create_tweet: async (params) => {
+        if (!hasTwitter()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Twitter not configured. Add twitter_bearer_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { text, media_ids, reply_to } = params;
+            const payload = { text };
+            if (media_ids?.length) payload.media = { media_ids };
+            if (reply_to) payload.reply = { in_reply_to_tweet_id: reply_to };
+            const response = await makeTwitterRequest('POST', 'tweets', payload);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.detail || error.response?.data?.title || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating tweet: ${errorMessage}` }] } };
+        }
+    },
+
+    tw_create_thread: async (params) => {
+        if (!hasTwitter()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Twitter not configured. Add twitter_bearer_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { tweets } = params;
+            if (!tweets || tweets.length < 2) {
+                return { toolResult: { isError: true, content: [{ type: "text", text: "A thread requires at least 2 tweets." }] } };
+            }
+            const results = [];
+            let lastTweetId = null;
+            for (const tweetText of tweets) {
+                const payload = { text: tweetText };
+                if (lastTweetId) payload.reply = { in_reply_to_tweet_id: lastTweetId };
+                const response = await makeTwitterRequest('POST', 'tweets', payload);
+                lastTweetId = response.data?.id;
+                results.push({ id: lastTweetId, text: tweetText });
+            }
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ thread_length: results.length, tweets: results }, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.detail || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating thread: ${errorMessage}` }] } };
+        }
+    },
+
+    tw_get_metrics: async (params) => {
+        if (!hasTwitter()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Twitter not configured. Add twitter_bearer_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { tweet_id } = params;
+            const response = await makeTwitterRequest('GET', `tweets/${tweet_id}?tweet.fields=public_metrics,created_at,text`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.detail || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error getting tweet metrics: ${errorMessage}` }] } };
+        }
+    },
+
+    tw_list_tweets: async (params) => {
+        if (!hasTwitter()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Twitter not configured. Add twitter_bearer_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const userId = getTwitterUserId();
+            const count = Math.min(params.count || 10, 100);
+            let endpoint = `users/${userId}/tweets?max_results=${count}&tweet.fields=public_metrics,created_at,text`;
+            if (params.since) endpoint += `&start_time=${params.since}`;
+            const response = await makeTwitterRequest('GET', endpoint);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.detail || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing tweets: ${errorMessage}` }] } };
+        }
+    },
+
+    tw_delete_tweet: async (params) => {
+        if (!hasTwitter()) {
+            return { toolResult: { isError: true, content: [{ type: "text", text: "Twitter not configured. Add twitter_bearer_token to WP_SITES_CONFIG." }] } };
+        }
+        try {
+            const { tweet_id } = params;
+            const response = await makeTwitterRequest('DELETE', `tweets/${tweet_id}`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify({ deleted: true, tweet_id }, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.detail || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error deleting tweet: ${errorMessage}` }] } };
+        }
+    },
+};