@omnisocials/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,139 @@
+# @omnisocials/mcp-server
+
+MCP (Model Context Protocol) server for the [OmniSocials](https://omnisocials.com) API. Lets AI assistants manage your social media — create posts, upload media, view analytics, and more.
+
+## Prerequisites
+
+- Node.js 18+
+- An OmniSocials API key (get one from **Settings > API** in the app)
+
+## Setup
+
+### Claude Code
+
+```bash
+claude mcp add omnisocials -- npx -y @omnisocials/mcp-server
+```
+
+Then set your API key:
+
+```bash
+export OMNISOCIALS_API_KEY=omsk_live_your_key_here
+```
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "omnisocials": {
+      "command": "npx",
+      "args": ["-y", "@omnisocials/mcp-server"],
+      "env": {
+        "OMNISOCIALS_API_KEY": "omsk_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "omnisocials": {
+      "command": "npx",
+      "args": ["-y", "@omnisocials/mcp-server"],
+      "env": {
+        "OMNISOCIALS_API_KEY": "omsk_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to your `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "omnisocials": {
+      "command": "npx",
+      "args": ["-y", "@omnisocials/mcp-server"],
+      "env": {
+        "OMNISOCIALS_API_KEY": "omsk_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Posts (7 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_posts` | List all posts, optionally filter by status |
+| `get_post` | Get details of a specific post |
+| `create_post` | Create a new post, story, or reel |
+| `create_and_publish_post` | Create and publish immediately |
+| `update_post` | Update a draft or scheduled post |
+| `delete_post` | Delete a post |
+| `publish_post` | Publish a draft or scheduled post now |
+
+### Media (3 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_media` | List all media files |
+| `upload_media` | Upload media from a URL (max 50MB) |
+| `delete_media` | Delete a media file |
+
+### Accounts (2 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_accounts` | List connected social media accounts |
+| `get_account` | Get account details |
+
+### Analytics (3 tools)
+
+| Tool | Description |
+|------|-------------|
+| `get_post_analytics` | Get stats for a published post |
+| `get_analytics_overview` | Overview analytics for a time period |
+| `get_account_analytics` | Account-level analytics (followers, etc.) |
+
+### Webhooks (5 tools)
+
+| Tool | Description |
+|------|-------------|
+| `list_webhooks` | List all webhooks |
+| `create_webhook` | Create a webhook for event notifications |
+| `get_webhook` | Get webhook details |
+| `update_webhook` | Update a webhook |
+| `delete_webhook` | Delete a webhook |
+| `rotate_webhook_secret` | Rotate a webhook's signing secret |
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `OMNISOCIALS_API_KEY` | Yes | Your API key (`omsk_live_*` or `omsk_test_*`) |
+| `OMNISOCIALS_BASE_URL` | No | Custom API base URL (defaults to production) |
+
+## API Documentation
+
+Full API docs: [docs.omnisocials.com](https://docs.omnisocials.com)
+
+## License
+
+MIT

package/build/client.d.ts

@@ -0,0 +1,87 @@
+import type { ApiResponse } from "./types.js";
+export declare class OmniSocialsClient {
+    private baseUrl;
+    private apiKey;
+    constructor(apiKey: string, baseUrl?: string);
+    request<T = unknown>(method: string, path: string, body?: unknown, queryParams?: Record<string, string>): Promise<ApiResponse<T>>;
+    listPosts(params?: {
+        status?: string;
+        limit?: string;
+        offset?: string;
+    }): Promise<ApiResponse<unknown>>;
+    getPost(id: string): Promise<ApiResponse<unknown>>;
+    createPost(data: {
+        content: string;
+        channels?: string[];
+        scheduled_at?: string;
+        media_ids?: string[] | Record<string, string[]>;
+        media_urls?: string[] | Record<string, string[]>;
+        type?: string;
+        pinterest?: Record<string, unknown>;
+        youtube?: Record<string, unknown>;
+        instagram?: Record<string, unknown>;
+        tiktok?: Record<string, unknown>;
+        x?: Record<string, unknown>;
+    }): Promise<ApiResponse<unknown>>;
+    createAndPublishPost(data: {
+        content: string;
+        channels?: string[];
+        media_ids?: string[] | Record<string, string[]>;
+        media_urls?: string[] | Record<string, string[]>;
+        type?: string;
+        pinterest?: Record<string, unknown>;
+        youtube?: Record<string, unknown>;
+        instagram?: Record<string, unknown>;
+        tiktok?: Record<string, unknown>;
+        x?: Record<string, unknown>;
+    }): Promise<ApiResponse<unknown>>;
+    updatePost(id: string, data: {
+        content?: string;
+        scheduled_at?: string;
+        channels?: string[];
+        media_ids?: string[] | Record<string, string[]>;
+        media_urls?: string[] | Record<string, string[]>;
+        type?: string;
+        pinterest?: Record<string, unknown>;
+        youtube?: Record<string, unknown>;
+        instagram?: Record<string, unknown>;
+        tiktok?: Record<string, unknown>;
+        x?: Record<string, unknown>;
+    }): Promise<ApiResponse<unknown>>;
+    deletePost(id: string): Promise<ApiResponse<unknown>>;
+    publishPost(id: string): Promise<ApiResponse<unknown>>;
+    listMedia(params?: {
+        limit?: string;
+        offset?: string;
+    }): Promise<ApiResponse<unknown>>;
+    uploadMedia(data: {
+        url: string;
+        filename?: string;
+    }): Promise<ApiResponse<unknown>>;
+    deleteMedia(id: string): Promise<ApiResponse<unknown>>;
+    listAccounts(): Promise<ApiResponse<unknown>>;
+    getAccount(id: string): Promise<ApiResponse<unknown>>;
+    getPostAnalytics(postId: string): Promise<ApiResponse<unknown>>;
+    getAnalyticsOverview(params?: {
+        period?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<ApiResponse<unknown>>;
+    getAccountAnalytics(params?: {
+        platform?: string;
+        date?: string;
+    }): Promise<ApiResponse<unknown>>;
+    listWebhooks(): Promise<ApiResponse<unknown>>;
+    createWebhook(data: {
+        url: string;
+        events: string[];
+    }): Promise<ApiResponse<unknown>>;
+    deleteWebhook(id: string): Promise<ApiResponse<unknown>>;
+    getWebhook(id: string): Promise<ApiResponse<unknown>>;
+    updateWebhook(id: string, data: {
+        url?: string;
+        events?: string[];
+        is_active?: boolean;
+    }): Promise<ApiResponse<unknown>>;
+    rotateWebhookSecret(id: string): Promise<ApiResponse<unknown>>;
+}

package/build/client.js

@@ -0,0 +1,108 @@
+export class OmniSocialsClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey;
+        this.baseUrl =
+            baseUrl || "https://app.omnisocials.com/api/v1";
+    }
+    async request(method, path, body, queryParams) {
+        let url = `${this.baseUrl}${path}`;
+        if (queryParams) {
+            const params = new URLSearchParams(Object.entries(queryParams).filter(([, v]) => v !== undefined));
+            const qs = params.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+        const options = { method, headers };
+        if (body && (method === "POST" || method === "PATCH" || method === "PUT")) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        if (response.status === 204) {
+            return { data: undefined };
+        }
+        const json = await response.json();
+        if (!response.ok) {
+            return {
+                error: json.error || {
+                    code: "api_error",
+                    message: `Request failed with status ${response.status}`,
+                },
+            };
+        }
+        return json;
+    }
+    // Posts
+    async listPosts(params) {
+        return this.request("GET", "/posts", undefined, params);
+    }
+    async getPost(id) {
+        return this.request("GET", `/posts/${id}`);
+    }
+    async createPost(data) {
+        return this.request("POST", "/posts/create", data);
+    }
+    async createAndPublishPost(data) {
+        return this.request("POST", "/posts/create-and-publish", data);
+    }
+    async updatePost(id, data) {
+        return this.request("PATCH", `/posts/${id}`, data);
+    }
+    async deletePost(id) {
+        return this.request("DELETE", `/posts/${id}`);
+    }
+    async publishPost(id) {
+        return this.request("POST", `/posts/${id}/publish`);
+    }
+    // Media
+    async listMedia(params) {
+        return this.request("GET", "/media", undefined, params);
+    }
+    async uploadMedia(data) {
+        return this.request("POST", "/media/upload-from-url", data);
+    }
+    async deleteMedia(id) {
+        return this.request("DELETE", `/media/${id}`);
+    }
+    // Accounts
+    async listAccounts() {
+        return this.request("GET", "/accounts");
+    }
+    async getAccount(id) {
+        return this.request("GET", `/accounts/${id}`);
+    }
+    // Analytics
+    async getPostAnalytics(postId) {
+        return this.request("GET", `/analytics/posts/${postId}`);
+    }
+    async getAnalyticsOverview(params) {
+        return this.request("GET", "/analytics/overview", undefined, params);
+    }
+    async getAccountAnalytics(params) {
+        return this.request("GET", "/analytics/accounts", undefined, params);
+    }
+    // Webhooks
+    async listWebhooks() {
+        return this.request("GET", "/webhooks");
+    }
+    async createWebhook(data) {
+        return this.request("POST", "/webhooks", data);
+    }
+    async deleteWebhook(id) {
+        return this.request("DELETE", `/webhooks/${id}`);
+    }
+    async getWebhook(id) {
+        return this.request("GET", `/webhooks/${id}`);
+    }
+    async updateWebhook(id, data) {
+        return this.request("PATCH", `/webhooks/${id}`, data);
+    }
+    async rotateWebhookSecret(id) {
+        return this.request("POST", `/webhooks/${id}/rotate-secret`);
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { OmniSocialsClient } from "./client.js";
+import { registerPostTools } from "./tools/posts.js";
+import { registerMediaTools } from "./tools/media.js";
+import { registerAccountTools } from "./tools/accounts.js";
+import { registerAnalyticsTools } from "./tools/analytics.js";
+import { registerWebhookTools } from "./tools/webhooks.js";
+const apiKey = process.env.OMNISOCIALS_API_KEY;
+if (!apiKey) {
+    console.error("Error: OMNISOCIALS_API_KEY environment variable is required.");
+    console.error("Get your API key from OmniSocials Settings > API.");
+    process.exit(1);
+}
+const baseUrl = process.env.OMNISOCIALS_BASE_URL;
+const client = new OmniSocialsClient(apiKey, baseUrl);
+const server = new McpServer({
+    name: "OmniSocials",
+    version: "1.0.0",
+});
+// Register all tools
+registerPostTools(server, client);
+registerMediaTools(server, client);
+registerAccountTools(server, client);
+registerAnalyticsTools(server, client);
+registerWebhookTools(server, client);
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+});

package/build/tools/accounts.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export declare function registerAccountTools(server: McpServer, client: OmniSocialsClient): void;

package/build/tools/accounts.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export function registerAccountTools(server, client) {
+    server.tool("list_accounts", "List all connected social media accounts in the workspace.", {}, async () => {
+        const result = await client.listAccounts();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_account", "Get details of a specific connected social media account.", {
+        id: z.string().describe("The account ID"),
+    }, async ({ id }) => {
+        const result = await client.getAccount(id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/build/tools/analytics.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export declare function registerAnalyticsTools(server: McpServer, client: OmniSocialsClient): void;

package/build/tools/analytics.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export function registerAnalyticsTools(server, client) {
+    server.tool("get_post_analytics", "Get analytics/statistics for a specific published post (impressions, engagements, likes, etc.).", {
+        post_id: z.string().describe("The post ID to get analytics for"),
+    }, async ({ post_id }) => {
+        const result = await client.getPostAnalytics(post_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_analytics_overview", "Get an overview of analytics across all posts and accounts for a time period.", {
+        period: z.string().optional().describe("Time period: 7d, 30d, 90d (default: 30d)"),
+        start_date: z.string().optional().describe("Custom start date (ISO 8601)"),
+        end_date: z.string().optional().describe("Custom end date (ISO 8601)"),
+    }, async (params) => {
+        const result = await client.getAnalyticsOverview(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_account_analytics", "Get account-level analytics (followers, subscribers, etc.) for connected social accounts.", {
+        platform: z.string().optional().describe("Filter by platform (e.g., instagram, youtube)"),
+        date: z.string().optional().describe("Date to get analytics for (YYYY-MM-DD, defaults to today)"),
+    }, async (params) => {
+        const result = await client.getAccountAnalytics(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/build/tools/media.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export declare function registerMediaTools(server: McpServer, client: OmniSocialsClient): void;

package/build/tools/media.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function registerMediaTools(server, client) {
+    server.tool("list_media", "List all media files in the workspace.", {
+        limit: z.string().optional().describe("Max results to return"),
+        offset: z.string().optional().describe("Offset for pagination"),
+    }, async (params) => {
+        const result = await client.listMedia(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("upload_media", "Upload media from a URL. The file will be downloaded and stored. Max 50MB.", {
+        url: z.string().describe("Public URL of the media file to upload"),
+        filename: z.string().optional().describe("Optional filename for the uploaded media"),
+    }, async (params) => {
+        const result = await client.uploadMedia(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("delete_media", "Delete a media file by ID.", {
+        id: z.string().describe("The media ID to delete"),
+    }, async ({ id }) => {
+        const result = await client.deleteMedia(id);
+        return {
+            content: [{ type: "text", text: result.error ? JSON.stringify(result.error) : "Media deleted successfully." }],
+        };
+    });
+}

package/build/tools/posts.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export declare function registerPostTools(server: McpServer, client: OmniSocialsClient): void;

package/build/tools/posts.js

@@ -0,0 +1,137 @@
+import { z } from "zod";
+export function registerPostTools(server, client) {
+    server.tool("list_posts", "List all posts in the workspace. Optionally filter by status.", {
+        status: z.string().optional().describe("Filter by status: draft, scheduled, published, failed"),
+        limit: z.string().optional().describe("Max results to return (default: 20)"),
+        offset: z.string().optional().describe("Offset for pagination"),
+    }, async (params) => {
+        const result = await client.listPosts(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_post", "Get details of a specific post by ID.", {
+        id: z.string().describe("The post ID"),
+    }, async ({ id }) => {
+        const result = await client.getPost(id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_post", "Create a new social media post, story, or reel. Specify content, target channels, type, and optional platform-specific options.", {
+        content: z.string().describe("The post content/caption text"),
+        channels: z.array(z.string()).optional().describe("Array of channel IDs to post to"),
+        scheduled_at: z.string().optional().describe("ISO 8601 date for scheduled publishing"),
+        media_ids: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("Media IDs from upload — flat array (same for all platforms) or object with platform keys: { default: [...], instagram: [...] }"),
+        media_urls: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("External image/video URLs — flat array (same for all platforms) or object with platform keys: { default: [...], instagram: [...], pinterest: [...] }. Max 10 total."),
+        type: z.enum(["post", "story", "reel"]).optional().describe("Content type: 'post' (default), 'story' (Instagram/Facebook/Snapchat), 'reel' (Instagram/Facebook/YouTube/TikTok)"),
+        pinterest: z.object({
+            board_id: z.string().optional(),
+            title: z.string().optional(),
+            link: z.string().optional(),
+        }).optional().describe("Pinterest-specific options"),
+        youtube: z.object({
+            title: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            privacy_status: z.enum(["public", "private", "unlisted"]).optional(),
+            category_id: z.string().optional(),
+            made_for_kids: z.boolean().optional(),
+            notify_subscribers: z.boolean().optional(),
+            contains_synthetic_media: z.boolean().optional(),
+        }).optional().describe("YouTube Shorts options"),
+        instagram: z.object({
+            share_to_feed: z.boolean().optional(),
+            thumbnail_type: z.enum(["from-video", "from-library"]).optional(),
+            thumb_offset: z.number().optional(),
+            cover_url: z.string().optional(),
+        }).optional().describe("Instagram Reel options"),
+        tiktok: z.object({
+            privacy_level: z.enum(["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"]).optional(),
+            disable_comment: z.boolean().optional(),
+            disable_duet: z.boolean().optional(),
+            disable_stitch: z.boolean().optional(),
+            is_aigc: z.boolean().optional(),
+            brand_content_toggle: z.boolean().optional(),
+        }).optional().describe("TikTok options"),
+        x: z.object({
+            reply_settings: z.enum(["", "following", "mentionedUsers"]).optional(),
+        }).optional().describe("X (Twitter) options"),
+    }, async (params) => {
+        const result = await client.createPost(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_and_publish_post", "Create a new post and publish it immediately to all selected platforms. No scheduling needed.", {
+        content: z.string().describe("The post content/caption text"),
+        channels: z.array(z.string()).optional().describe("Array of channel IDs to post to"),
+        media_ids: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("Media IDs from upload — flat array or per-platform object"),
+        media_urls: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("External image/video URLs — flat array or per-platform object. Max 10 total."),
+        type: z.enum(["post", "story", "reel"]).optional().describe("Content type: 'post' (default), 'story', 'reel'"),
+        pinterest: z.object({
+            board_id: z.string().optional(),
+            title: z.string().optional(),
+            link: z.string().optional(),
+        }).optional().describe("Pinterest-specific options"),
+        youtube: z.object({
+            title: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            privacy_status: z.enum(["public", "private", "unlisted"]).optional(),
+        }).optional().describe("YouTube Shorts options"),
+        tiktok: z.object({
+            privacy_level: z.enum(["PUBLIC_TO_EVERYONE", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "SELF_ONLY"]).optional(),
+        }).optional().describe("TikTok options"),
+    }, async (params) => {
+        const result = await client.createAndPublishPost(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("update_post", "Update an existing post. Only draft and scheduled posts can be updated.", {
+        id: z.string().describe("The post ID to update"),
+        content: z.string().optional().describe("Updated post content"),
+        scheduled_at: z.string().optional().describe("Updated scheduled date (ISO 8601)"),
+        channels: z.array(z.string()).optional().describe("Updated channel IDs"),
+        media_ids: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("Media IDs — flat array or per-platform object"),
+        media_urls: z.union([
+            z.array(z.string()),
+            z.record(z.string(), z.array(z.string())),
+        ]).optional().describe("External URLs — flat array or per-platform object. Max 10 total."),
+    }, async ({ id, ...data }) => {
+        const result = await client.updatePost(id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("delete_post", "Delete a post by ID. This action cannot be undone.", {
+        id: z.string().describe("The post ID to delete"),
+    }, async ({ id }) => {
+        const result = await client.deletePost(id);
+        return {
+            content: [{ type: "text", text: result.error ? JSON.stringify(result.error) : "Post deleted successfully." }],
+        };
+    });
+    server.tool("publish_post", "Publish a draft or scheduled post immediately. The post will be queued for immediate publishing.", {
+        id: z.string().describe("The post ID to publish"),
+    }, async ({ id }) => {
+        const result = await client.publishPost(id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/build/tools/webhooks.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { OmniSocialsClient } from "../client.js";
+export declare function registerWebhookTools(server: McpServer, client: OmniSocialsClient): void;

package/build/tools/webhooks.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export function registerWebhookTools(server, client) {
+    server.tool("list_webhooks", "List all configured webhooks.", {}, async () => {
+        const result = await client.listWebhooks();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_webhook", "Create a new webhook to receive event notifications. Available events: post.scheduled, post.published, post.failed", {
+        url: z.string().describe("The HTTPS URL to send webhook events to"),
+        events: z.array(z.string()).describe("Events to subscribe to: post.scheduled, post.published, post.failed"),
+    }, async (params) => {
+        const result = await client.createWebhook(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_webhook", "Get details of a specific webhook by ID.", {
+        id: z.string().describe("The webhook ID"),
+    }, async ({ id }) => {
+        const result = await client.getWebhook(id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("update_webhook", "Update a webhook's URL, events, or active status.", {
+        id: z.string().describe("The webhook ID to update"),
+        url: z.string().optional().describe("Updated HTTPS URL"),
+        events: z.array(z.string()).optional().describe("Updated event list"),
+        is_active: z.boolean().optional().describe("Enable or disable the webhook"),
+    }, async ({ id, ...data }) => {
+        const result = await client.updateWebhook(id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("delete_webhook", "Delete a webhook by ID. You will stop receiving notifications at this URL.", {
+        id: z.string().describe("The webhook ID to delete"),
+    }, async ({ id }) => {
+        const result = await client.deleteWebhook(id);
+        return {
+            content: [{ type: "text", text: result.error ? JSON.stringify(result.error) : "Webhook deleted successfully." }],
+        };
+    });
+    server.tool("rotate_webhook_secret", "Rotate the signing secret for a webhook. The new secret will only be shown once.", {
+        id: z.string().describe("The webhook ID"),
+    }, async ({ id }) => {
+        const result = await client.rotateWebhookSecret(id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/build/types.d.ts

@@ -0,0 +1,56 @@
+export interface ApiResponse<T = unknown> {
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface Post {
+    id: string;
+    content: string;
+    status: string;
+    scheduled_at: string | null;
+    published_at: string | null;
+    channels: string[];
+    media: string[];
+    created_at: string;
+}
+export interface MediaItem {
+    id: string;
+    url: string;
+    type: string;
+    filename: string;
+    size: number;
+    created_at: string;
+}
+export interface Account {
+    id: string;
+    platform: string;
+    username: string;
+    profile_picture: string | null;
+    is_connected: boolean;
+}
+export interface Webhook {
+    id: string;
+    url: string;
+    events: string[];
+    is_active: boolean;
+    last_triggered_at: string | null;
+    failure_count: number;
+    created_at: string;
+}
+export interface AnalyticsOverview {
+    total_posts: number;
+    total_impressions: number;
+    total_engagements: number;
+    period: string;
+}
+export interface PostAnalytics {
+    post_id: string;
+    impressions: number;
+    engagements: number;
+    likes: number;
+    comments: number;
+    shares: number;
+    platform_stats: Record<string, unknown>;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@omnisocials/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for OmniSocials API - manage social media posts, media, accounts, analytics, and webhooks",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "omnisocials-mcp": "build/index.js"
+  },
+  "files": [
+    "build/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "omnisocials",
+    "social-media",
+    "claude",
+    "model-context-protocol",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/omnisocials/mcp-server"
+  },
+  "homepage": "https://docs.omnisocials.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.8.2"
+  }
+}