@codingmantra/mcp-server 0.2.2 → 0.3.0

package/README.md

@@ -2,14 +2,16 @@
 
 The official **Model Context Protocol (MCP)** server connecting AI assistants (Claude Desktop, Cursor, Cline, and Antigravity) to CodingMantra's generative AI media engines.
 
-## What's New in v0.2.2
+## What's New in v0.3.0
+- **Social media workflows:** 15 tools for connected accounts, caption creation, drafts, gallery images, immediate publishing, scheduling, status, cancellation, and analytics. Uses the same CodingMantra API key.
+
 - **Current API coverage:** Story Teller, HeyGen Talking Avatar IV, and Jewellery Rate Poster tools.
 - **Video contract alignment:** Required prompt/model/duration/resolution/aspect ratio, character descriptions, seed, guidance, and local reference-image resolution.
 - **Terminal job handling:** Polling stops for completed, failed, or cancelled jobs.
 
 - 🖼️ **Native MCP Image Output**: Generated images (including QR codes, logos, try-on shots, and product photos) return standard MCP `ImageContent` so they render directly in your AI assistant's chat window.
 - 📁 **Local File Path Resolution**: Pass local paths (e.g. `./shoe.png` or `/Users/.../portrait.jpg`) directly in tool arguments—the server automatically reads and encodes them as base64 data URIs.
-- ⚡ **Expanded Tool Suite (28 Tools)**: Expanded image generation support including Passport Photos, Baby Milestones, YouTube Thumbnails, Blog Images, Nano Banana, Professional Photography, Sketch-to-Real, Human Builder, Apparel/Product/Jewelry Try-On, Festival Posts, Upscaling, and Discovery.
+- ⚡ **Expanded Tool Suite (43 Tools)**: Expanded image generation support including Passport Photos, Baby Milestones, YouTube Thumbnails, Blog Images, Nano Banana, Professional Photography, Sketch-to-Real, Human Builder, Apparel/Product/Jewelry Try-On, Festival Posts, Upscaling, and Discovery.
 - 🎯 **Advanced Model & Resolution Parameters**: Direct support for `model`, `modelId`, `promptId`, custom reference images, and server-side credit synchronization.
 - 🛡️ **Graceful Error Handling & 120s Timeout**: Informative error diagnostics when API keys are missing or requests time out, with clean stdio protocol execution.
 
@@ -17,7 +19,7 @@ The official **Model Context Protocol (MCP)** server connecting AI assistants (C
 
 ## Features & Tool Suite
 
-The server exposes **28 specialized generative and utility tools** over standard I/O (`stdio`):
+The server exposes **43 specialized generative and utility tools** over standard I/O (`stdio`):
 
 ### 1. Synchronous Image Generation (Immediate Inline Image Output)
 - **`generate_product_photo`** — Generates studio-grade commercial product photos with custom background scenes, ambient occlusion contact shadows, camera optics, resolutions (1K, 2K, 4K), aspect ratios, and dynamic logo/text overlays.
@@ -60,6 +62,52 @@ All generations automatically deduct credits from your CodingMantra wallet and p
 
 ---
 
+### 5. Social Content & Scheduling
+
+- **`get_social_workflow`** — Capabilities, workflow, content guidance, and platform limits.
+- **`list_social_accounts`** — Connected Facebook Pages and Instagram accounts; no provider tokens.
+- **`generate_social_caption`** — Generate or refine a caption and hashtags using images, brandBrief, and saved brand context. Uses credits.
+- **`list_social_drafts`** — Paginated saved drafts (20 per page).
+- **`save_social_draft`** — Create or fully replace a draft; uploads local images. Does not schedule or publish.
+- **`delete_social_draft`** — Remove a saved draft.
+- **`list_social_media`** — Paginate your generated image gallery.
+- **`schedule_social_post`** — Queue final content for automatic future delivery to selected accounts.
+- **`list_social_posts`** — Filter the posting calendar by status, platform, and date range.
+- **`get_social_post`** — Inspect status, errors, retries, and published job IDs.
+- **`update_social_post`** — Edit or reschedule a queued post; retry a failed post with a new future time.
+- **`cancel_social_post`** — Stop a queued post before publication starts.
+- **`delete_social_post`** — Delete an eligible schedule record; does not delete a live platform post.
+- **`publish_social_post`** — Post immediately to one connected account.
+- **`get_social_analytics`** — Recorded reach, engagement, totals, top posts, and posting activity.
+
+#### Working with Claude, Codex, Antigravity, and other assistants
+
+Connect accounts once in the [Social Media Hub](https://codingmantra.com/tools/digital-marketing/social-media-hub). The same `CODINGMANTRA_API_KEY` used for media generation identifies the owner of all drafts and schedules; browser cookies and Meta access tokens are not needed in your assistant. Account connection/reconnection remains in the browser. Any assistant supporting standard MCP stdio can discover the tools and their schemas. Responses include text plus structured JSON, UTC ISO timestamps, IDs, and pagination fields.
+
+Try: “Create three Facebook posts for my bakery’s launch. Use a warm voice and these verified opening hours. Save drafts for review, then schedule the approved posts at 9 AM Asia/Kolkata next week.” Or: “Show failed posts, explain their errors, and move this queued post to tomorrow at 6 PM Asia/Kolkata.”
+
+Start with `get_social_workflow` and `list_social_accounts`. Use exact returned account IDs. Supply `brandBrief` to isolate a particular brand; otherwise caption generation uses saved brand context. Provide audience, verified facts, tone, offer, and CTA. Combine caption generation with existing image tools, or write captions directly in your assistant without AI credit charges.
+
+Instagram supports **exactly one image**, with at most **2,200 characters including hashtags**. Facebook supports text and up to 10 images, with 63,206 characters including hashtags. Video/reel publishing and other networks are not implemented. Generated images may use local file paths; the server resolves them and the backend persists them when drafts or schedules are saved.
+
+Scheduling requires `platforms`, `content.caption` (may be empty if there is an image), and a future `scheduledFor` ISO timestamp with an explicit UTC offset. Do not guess an ambiguous timezone. Use `draftId` when queuing a saved draft: the backend atomically consumes it and repeated requests return the same schedule. Immediate publishing has no idempotency guarantee; inspect publication state before retrying a timeout. Successful schedules publish on the backend cron worker even when the assistant is offline.
+
+```json
+{
+  "draftId": "returned_draft_id",
+  "platforms": [{ "platform": "facebook", "accountId": "returned_page_id", "accountName": "My Bakery" }],
+  "content": {
+    "caption": "Our opening day is almost here. Join us for fresh bread!",
+    "hashtags": ["bakery", "freshbread"],
+    "mediaUrls": ["https://example.com/my-generated-image.png"]
+  },
+  "scheduledFor": "2026-10-10T09:00:00+05:30"
+}
+```
+
+Deployment order: deploy the updated web API, verify the cron worker, then release/use MCP v0.3.0. The backend must support bearer API keys; older browser-session-only endpoints return 401. For REST examples and the route map, see the repository’s `docs/social-mcp-api.md`.
+
+
 ## Video parameters
 
 General video tools require `prompt` (10–5000 characters), `model`, `timeDuration`, `resolution`, and `aspectRatio`. Use model-supported settings; Veo requires 8 seconds for 1080p, references, or an end frame. Choose one image mode: main image, frames, or references. Reference images accept URLs, data URIs, or local paths (up to 3 for Veo). Optional settings include characters, seed, guidanceScale, soundEffects, and styleAmbiance.

package/build/index.js

@@ -2,12 +2,14 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { AjvJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/ajv";
 import { apiClient } from './api-client.js';
 import { formatImageToolResult, resolveImageInput, resolveImagesArray } from './image-utils.js';
 const server = new Server({
     name: "codingmantra-mcp",
-    version: "0.2.2",
+    version: "0.3.0",
 }, {
+    instructions: "For social media, start with get_social_workflow and list_social_accounts. Create captions and images, save drafts for review, then schedule or publish according to the user’s request. Use exact connected account IDs and explicit timezone offsets. Only Facebook Pages and Instagram image posts are supported. Keep social provider tokens on the backend.",
     capabilities: {
         tools: {},
     },
@@ -942,10 +944,209 @@ const CHECK_JOB_STATUS_TOOL = {
         required: ["jobId"]
     }
 };
+// Social tools share the same API key as media generation; social tokens stay on the server.
+const SOCIAL_ACCOUNT_SCHEMA = {
+    type: 'object', properties: {
+        platform: { type: 'string', enum: ['facebook', 'instagram'], description: 'Connected social platform.' },
+        accountId: { type: 'string', minLength: 1, description: 'Exact account ID returned by list_social_accounts.' },
+        accountName: { type: 'string', minLength: 1, description: 'Account display name returned by list_social_accounts.' },
+    }, required: ['platform', 'accountId', 'accountName'],
+};
+const SOCIAL_CONTENT_PROPERTIES = {
+    caption: { type: 'string', maxLength: 63206, description: 'Post text. Instagram caption plus hashtags must fit 2200 characters.' },
+    brandBrief: { type: 'string', maxLength: 4000, description: 'Brand name, audience, voice, offer, facts, and call to action for this post.' },
+    hashtags: { type: 'array', maxItems: 30, items: { type: 'string', description: 'Hashtag with or without a leading #.' }, description: 'Relevant hashtags; duplicates already in the caption are omitted during publication.' },
+    mediaUrls: { type: 'array', maxItems: 10, items: { type: 'string', description: 'HTTPS image URL, PNG/JPEG/WebP data URI, or local image path.' }, description: 'Images only. Instagram currently requires exactly one image; Facebook accepts up to 10.' },
+};
+const SOCIAL_SCHEDULE_PROPERTIES = {
+    draftId: { type: 'string', description: 'Optional saved draft ID. Scheduling consumes it atomically; repeating this request returns the same scheduled post.' },
+    socialContentId: { type: 'string', description: 'Optional media library content ID for tracking.' },
+    platforms: { type: 'array', minItems: 1, maxItems: 20, items: SOCIAL_ACCOUNT_SCHEMA, description: 'Connected accounts to publish to; select each account once.' },
+    content: { type: 'object', properties: SOCIAL_CONTENT_PROPERTIES, required: ['caption'], description: 'Final post caption, hashtags, brand brief, and images.' },
+    scheduledFor: { type: 'string', format: 'date-time', description: 'Future ISO 8601 timestamp with explicit UTC offset, e.g. 2026-10-10T09:00:00+05:30. Resolve the user’s timezone before scheduling.' },
+};
+const SOCIAL_ID = { type: 'string', minLength: 1, pattern: '^[A-Za-z0-9_-]+$', description: 'Exact draft or scheduled post ID returned by a social tool.' };
+const socialRead = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
+const socialWrite = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+const socialDelete = { ...socialWrite, destructiveHint: true, idempotentHint: true };
+const SOCIAL_TOOLS = [
+    { name: 'get_social_workflow', description: 'Read the social workflow, capabilities, timezone guidance, and platform restrictions before planning content or posting. Read-only; no API call.', annotations: { ...socialRead, openWorldHint: false }, inputSchema: { type: 'object', properties: {} } },
+    { name: 'list_social_accounts', description: 'List connected Facebook Pages and Instagram accounts with IDs, names, permissions, and reconnect status. Read-only; OAuth tokens are never returned. Connect accounts in the web hub first.', annotations: socialRead, inputSchema: { type: 'object', properties: {} } },
+    { name: 'generate_social_caption', description: 'Synchronously create or refine a caption and hashtags from a brief or images. Uses wallet credits and saved brand context unless brandBrief is supplied. Does not publish. Include verified facts, audience, tone, and CTA in the brief; review the result.', annotations: socialWrite, inputSchema: { type: 'object', properties: { ...SOCIAL_CONTENT_PROPERTIES, platform: { type: 'string', enum: ['facebook', 'instagram'], description: 'Target platform; defaults to Instagram.' } } } },
+    { name: 'list_social_drafts', description: 'Read saved drafts, including captions, images, account selections, and proposed dates. Returns 20 per page; use offset for pagination.', annotations: socialRead, inputSchema: { type: 'object', properties: { offset: { type: 'integer', minimum: 0, description: 'Number of drafts to skip.' } } } },
+    { name: 'save_social_draft', description: 'Save a new draft or replace an existing draft by id. Does not queue or publish. Send the complete draft when editing; omitted fields use API defaults. Local images are uploaded and persisted.', annotations: socialWrite, inputSchema: { type: 'object', properties: { ...SOCIAL_CONTENT_PROPERTIES, id: SOCIAL_ID, platforms: { type: 'array', items: SOCIAL_ACCOUNT_SCHEMA, description: 'Optional target accounts; drafts may have no accounts yet.' }, scheduledFor: { type: ['string', 'null'], format: 'date-time', description: 'Optional proposed date with explicit offset; saving does not schedule.' }, socialContentId: { type: 'string', description: 'Optional media library content ID.' } } } },
+    { name: 'delete_social_draft', description: 'Delete one saved draft belonging to the API-key owner. Does not delete a scheduled or published post.', annotations: socialDelete, inputSchema: { type: 'object', properties: { id: SOCIAL_ID }, required: ['id'] } },
+    { name: 'list_social_media', description: 'Read generated images from your gallery for use in posts. Returns public media URLs; use existing image generation tools to create new visuals.', annotations: socialRead, inputSchema: { type: 'object', properties: { page: { type: 'integer', minimum: 1, description: 'Gallery page (default 1).' }, limit: { type: 'integer', minimum: 1, maximum: 50, description: 'Images per page (default 24).' } } } },
+    { name: 'schedule_social_post', description: 'Queue a final post for automatic future publication to connected accounts. Returns a scheduled post ID. ISO timestamps require a UTC offset; the server scheduler publishes even when this assistant is offline. Use draftId to avoid duplicate draft scheduling.', annotations: socialWrite, inputSchema: { type: 'object', properties: SOCIAL_SCHEDULE_PROPERTIES, required: ['platforms', 'content', 'scheduledFor'] } },
+    { name: 'list_social_posts', description: 'Read scheduled, published, failed, or cancelled posts. Filter by platform, status, or date range; use limit/offset for pagination. Dates must include a UTC offset.', annotations: socialRead, inputSchema: { type: 'object', properties: {
+                status: { type: 'string', enum: ['scheduled', 'published', 'failed', 'cancelled'], description: 'Post status filter.' },
+                platform: { type: 'string', enum: ['facebook', 'instagram'], description: 'Platform filter.' },
+                fromDate: { type: 'string', format: 'date-time', description: 'Inclusive start timestamp with offset.' },
+                toDate: { type: 'string', format: 'date-time', description: 'Inclusive end timestamp with offset.' },
+                limit: { type: 'integer', minimum: 1, maximum: 500, description: 'Page size, default 50.' },
+                offset: { type: 'integer', minimum: 0, description: 'Number of posts to skip.' },
+            } } },
+    { name: 'get_social_post', description: 'Read one scheduled post, including status, error, retries, and published job IDs. Check this before retrying a failed or ambiguous publication.', annotations: socialRead, inputSchema: { type: 'object', properties: { id: SOCIAL_ID }, required: ['id'] } },
+    { name: 'update_social_post', description: 'Edit a pending schedule, content, or target accounts. Provide a new future scheduledFor to reschedule or retry a failed post. The API rejects changes to posts that are publishing or already published.', annotations: { ...socialWrite, idempotentHint: true }, inputSchema: { type: 'object', properties: { id: SOCIAL_ID, content: { type: 'object', properties: SOCIAL_CONTENT_PROPERTIES, description: 'Fields to change; omitted fields retain their existing values.' }, platforms: SOCIAL_SCHEDULE_PROPERTIES.platforms, scheduledFor: SOCIAL_SCHEDULE_PROPERTIES.scheduledFor }, required: ['id'] } },
+    { name: 'cancel_social_post', description: 'Cancel a queued post so it will not publish. The API rejects cancellation while publishing or after publication. Does not remove an already published platform post.', annotations: socialDelete, inputSchema: { type: 'object', properties: { id: SOCIAL_ID }, required: ['id'] } },
+    { name: 'delete_social_post', description: 'Remove a schedule record. The API prevents deletion during publishing or after publication. Does not delete a live Facebook or Instagram post.', annotations: socialDelete, inputSchema: { type: 'object', properties: { id: SOCIAL_ID }, required: ['id'] } },
+    { name: 'publish_social_post', description: 'Publish immediately to one connected Facebook Page or Instagram account when the user requests posting now. Returns the platform publication result. Images only; Instagram requires exactly one image. Avoid blind retries after timeouts because a post may already be live.', annotations: { ...socialWrite, destructiveHint: true }, inputSchema: { type: 'object', properties: { ...SOCIAL_CONTENT_PROPERTIES, platform: { type: 'string', enum: ['facebook', 'instagram'], description: 'Platform to publish to.' }, accountId: { type: 'string', minLength: 1, description: 'Exact connected account ID from list_social_accounts.' }, socialContentId: { type: 'string', description: 'Optional media library content ID for publication tracking.' }, link: { type: 'string', description: 'Optional HTTPS link for a Facebook post.' } }, required: ['platform', 'accountId', 'caption'] } },
+    { name: 'get_social_analytics', description: 'Read recorded publishing totals, reach, engagement, top posts, and posting activity. Metrics reflect stored provider data and may be incomplete; these are not guaranteed optimal posting times.', annotations: socialRead, inputSchema: { type: 'object', properties: { range: { type: 'string', enum: ['7d', '30d', '90d'], description: 'Reporting range, default 30d.' }, platform: { type: 'string', enum: ['facebook', 'instagram'], description: 'Optional platform filter.' }, accountId: { type: 'string', description: 'Optional connected account filter.' } } } },
+];
+const socialSchemaValidator = new AjvJsonSchemaValidator();
+const socialValidators = new Map(SOCIAL_TOOLS.map(tool => [tool.name, socialSchemaValidator.getValidator(tool.inputSchema)]));
+function normalizeSocialDates(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeSocialDates);
+    if (value && typeof value === 'object') {
+        const object = value;
+        const seconds = object._seconds ?? object.seconds;
+        if (typeof seconds === 'number' && Object.keys(object).every(key => ['_seconds', '_nanoseconds', 'seconds', 'nanoseconds'].includes(key))) {
+            return new Date(seconds * 1000).toISOString();
+        }
+        return Object.fromEntries(Object.entries(object).map(([key, nested]) => [key, normalizeSocialDates(nested)]));
+    }
+    return value;
+}
+function socialImage(value) {
+    if (typeof value !== 'string')
+        throw new Error('Each media image must be a URL, data URI, or local file path.');
+    const resolved = resolveImageInput(value);
+    if (/^data:image\/(jpeg|png|webp);base64,/i.test(resolved))
+        return resolved;
+    try {
+        if (new URL(resolved).protocol === 'https:')
+            return resolved;
+    }
+    catch { /* invalid source */ }
+    throw new Error('Use an HTTPS image URL or a local PNG, JPEG, or WebP file.');
+}
+function socialQuery(args, allowed) {
+    const query = new URLSearchParams();
+    for (const key of allowed)
+        if (args[key] !== undefined)
+            query.set(key, String(args[key]));
+    return query.size ? `?${query}` : '';
+}
+function socialId(args) {
+    if (typeof args.id !== 'string' || !/^[A-Za-z0-9_-]+$/.test(args.id))
+        throw new Error('Provide a valid post or draft ID.');
+    return encodeURIComponent(args.id);
+}
+async function executeSocialTool(name, rawArgs) {
+    const validated = socialValidators.get(name)(rawArgs);
+    if (!validated.valid)
+        throw new Error(`Invalid ${name} parameters: ${validated.errorMessage}`);
+    const args = { ...rawArgs };
+    if (args.mediaUrls !== undefined) {
+        if (!Array.isArray(args.mediaUrls))
+            throw new Error('mediaUrls must be an array.');
+        args.mediaUrls = args.mediaUrls.map(socialImage);
+    }
+    if (args.content !== undefined) {
+        if (!args.content || typeof args.content !== 'object' || Array.isArray(args.content))
+            throw new Error('content must be a post object.');
+        const content = { ...args.content };
+        if (content.mediaUrls !== undefined) {
+            if (!Array.isArray(content.mediaUrls))
+                throw new Error('content.mediaUrls must be an array.');
+            content.mediaUrls = content.mediaUrls.map(socialImage);
+        }
+        args.content = content;
+    }
+    let result;
+    if (name === 'get_social_workflow') {
+        result = {
+            supportedPlatforms: ['facebook', 'instagram'],
+            connectUrl: 'https://codingmantra.com/tools/digital-marketing/social-media-hub',
+            steps: ['list_social_accounts', 'generate_social_caption or write a caption with your assistant', 'generate an image with existing MCP tools or list_social_media', 'save_social_draft for review', 'schedule_social_post or publish_social_post as requested', 'list_social_posts / get_social_post / get_social_analytics'],
+            limits: { instagram: { images: 1, captionIncludingHashtags: 2200 }, facebook: { maxImages: 10, captionIncludingHashtags: 63206 }, videoPublishing: false },
+            timezone: 'Ask for the user’s intended timezone when ambiguous; convert to an ISO 8601 timestamp with an explicit UTC offset. Dates are returned as ISO 8601 UTC timestamps.',
+            contentGuidance: 'Use a clear hook, useful verified facts, the intended audience and brand voice, and one CTA. Supply brandBrief to generate_social_caption for per-brand context. Never invent prices, claims, discounts, or business details. Caption generation uses credits; drafts and schedules do not run AI.',
+            scheduling: 'The deployed backend requires its cron scheduler to run. The assistant does not need to remain online. Saved drafts are consumed atomically; reuse draftId to make repeated scheduling requests safe.',
+            retries: 'Inspect failed post errors and publishedJobIds before rescheduling. Immediate publication has no idempotency guarantee; do not automatically retry ambiguous timeouts.',
+        };
+    }
+    else {
+        let endpoint = '';
+        let method = 'GET';
+        let body;
+        if (name === 'list_social_accounts')
+            endpoint = '/social/meta/connection';
+        if (name === 'generate_social_caption') {
+            endpoint = '/social/caption';
+            method = 'POST';
+            body = { caption: args.caption || '', brandBrief: args.brandBrief || '', mediaUrls: args.mediaUrls || [], platform: args.platform || 'instagram' };
+        }
+        if (name === 'list_social_drafts')
+            endpoint = '/social/drafts' + socialQuery(args, ['offset']);
+        if (name === 'save_social_draft') {
+            endpoint = '/social/drafts';
+            method = 'POST';
+            body = args;
+        }
+        if (name === 'delete_social_draft') {
+            endpoint = `/social/drafts?id=${socialId(args)}`;
+            method = 'DELETE';
+        }
+        if (name === 'list_social_media')
+            endpoint = '/social/gallery' + socialQuery({ ...args, type: 'image' }, ['type', 'page', 'limit']);
+        if (name === 'schedule_social_post') {
+            endpoint = '/social/schedule';
+            method = 'POST';
+            body = args;
+        }
+        if (name === 'list_social_posts')
+            endpoint = '/social/schedule' + socialQuery(args, ['status', 'platform', 'fromDate', 'toDate', 'limit', 'offset']);
+        if (['get_social_post', 'update_social_post', 'cancel_social_post', 'delete_social_post'].includes(name)) {
+            endpoint = `/social/schedule/${socialId(args)}`;
+            if (name === 'update_social_post') {
+                method = 'PATCH';
+                const { id: _id, ...updates } = args;
+                body = updates;
+            }
+            if (name === 'cancel_social_post') {
+                method = 'PATCH';
+                body = { status: 'cancelled' };
+            }
+            if (name === 'delete_social_post')
+                method = 'DELETE';
+        }
+        if (name === 'publish_social_post') {
+            endpoint = '/social/meta/publish';
+            method = 'POST';
+            const caption = typeof args.caption === 'string' ? args.caption.trim() : '';
+            if (args.hashtags !== undefined && (!Array.isArray(args.hashtags) || args.hashtags.some(tag => typeof tag !== 'string' || !/^#?[\p{L}\p{N}_]+$/u.test(tag))))
+                throw new Error('Use valid hashtags containing letters, numbers, or underscores.');
+            const existing = new Set((caption.match(/#[\p{L}\p{N}_]+/gu) || []).map(tag => tag.toLowerCase()));
+            const tags = (args.hashtags || []).map(tag => `#${tag.replace(/^#/, '')}`).filter(tag => {
+                if (existing.has(tag.toLowerCase()))
+                    return false;
+                existing.add(tag.toLowerCase());
+                return true;
+            });
+            const text = [caption, tags.join(' ')].filter(Boolean).join('\n\n');
+            const images = args.mediaUrls || [];
+            if (!['facebook', 'instagram'].includes(String(args.platform)))
+                throw new Error('Choose Facebook or Instagram.');
+            if (args.platform === 'instagram' && images.length !== 1)
+                throw new Error('Instagram requires exactly one image.');
+            body = args.platform === 'instagram'
+                ? { platform: 'instagram', instagramId: args.accountId, caption: text, imageDataUrl: images[0]?.startsWith('data:') ? images[0] : undefined, imageUrl: images[0]?.startsWith('https:') ? images[0] : undefined, socialContentId: args.socialContentId }
+                : { platform: 'facebook', pageId: args.accountId, message: text, imageUrls: images.length ? images : undefined, link: args.link, socialContentId: args.socialContentId };
+        }
+        if (name === 'get_social_analytics')
+            endpoint = '/social/analytics' + socialQuery(args, ['range', 'platform', 'accountId']);
+        result = await apiClient(endpoint, { method, ...(body ? { body: JSON.stringify(body) } : {}) });
+    }
+    result = normalizeSocialDates(result);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], structuredContent: result, ...(result.success === false ? { isError: true } : {}) };
+}
 // ─── Tool Registration ─────────────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
+            ...SOCIAL_TOOLS,
             GENERATE_JEWELLERY_RATE_POSTER_TOOL,
             GENERATE_PRODUCT_PHOTO_TOOL,
             GENERATE_LOGO_TOOL,
@@ -981,6 +1182,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: rawArgs } = request.params;
+        if (SOCIAL_TOOLS.some(tool => tool.name === name))
+            return await executeSocialTool(name, rawArgs || {});
         const args = rawArgs || {};
         if (name === 'generate_jewellery_rate_poster') {
             const response = await apiClient('/image/jewellery-rate-poster', {
@@ -1346,7 +1549,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function run() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("[CodingMantra MCP] Server v0.2.2 initialized and running on stdio (28 tools active)");
+    console.error("[CodingMantra MCP] Server v0.3.0 initialized and running on stdio (43 tools active)");
 }
 run().catch((error) => {
     console.error("Fatal error running CodingMantra MCP server:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingmantra/mcp-server",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Official Model Context Protocol (MCP) Server for CodingMantra AI Generation Tools",
   "type": "module",
   "main": "build/index.js",