@omnisocials/mcp-server 1.12.0 → 1.13.0

package/build/client.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResponse, MediaItem, PdfUploadResult } from "./types.js";
+import type { ApiResponse, MediaItem, PdfUploadResult, InboxConversation, InboxMessage } from "./types.js";
 export declare function fetchImageAsBase64(url: string): Promise<{
     data: string;
     mimeType: string;
@@ -264,4 +264,21 @@ export declare class OmniSocialsClient {
         is_active?: boolean;
     }): Promise<ApiResponse<unknown>>;
     rotateWebhookSecret(id: string): Promise<ApiResponse<unknown>>;
+    listInboxConversations(params?: {
+        platform?: string;
+        type?: string;
+        unread?: string;
+        limit?: string;
+        cursor?: string;
+    }): Promise<ApiResponse<InboxConversation[]>>;
+    getInboxMessages(conversationId: string, params?: {
+        limit?: string;
+        cursor?: string;
+    }): Promise<ApiResponse<InboxMessage[]>>;
+    markInboxRead(conversationId: string): Promise<ApiResponse<unknown>>;
+    replyToInboxConversation(conversationId: string, data: {
+        text: string;
+        attachment_url?: string;
+        attachment_type?: string;
+    }): Promise<ApiResponse<InboxMessage>>;
 }

package/build/client.js

@@ -318,4 +318,18 @@ export class OmniSocialsClient {
     async rotateWebhookSecret(id) {
         return this.request("POST", `/webhooks/${id}/rotate-secret`);
     }
+    // Inbox — conversation ids can contain ":" and "()" (LinkedIn URNs), so any
+    // path segment built from one must be URL-encoded.
+    async listInboxConversations(params) {
+        return this.request("GET", "/inbox/conversations", undefined, params);
+    }
+    async getInboxMessages(conversationId, params) {
+        return this.request("GET", `/inbox/conversations/${encodeURIComponent(conversationId)}/messages`, undefined, params);
+    }
+    async markInboxRead(conversationId) {
+        return this.request("POST", `/inbox/conversations/${encodeURIComponent(conversationId)}/read`);
+    }
+    async replyToInboxConversation(conversationId, data) {
+        return this.request("POST", `/inbox/conversations/${encodeURIComponent(conversationId)}/reply`, data);
+    }
 }

package/build/index.js

@@ -8,6 +8,7 @@ import { registerMediaTools } from "./tools/media.js";
 import { registerAccountTools } from "./tools/accounts.js";
 import { registerAnalyticsTools } from "./tools/analytics.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
+import { registerInboxTools } from "./tools/inbox.js";
 import { registerWorkspaceTools } from "./tools/workspaces.js";
 const apiKeyEnv = process.env.OMNISOCIALS_API_KEY;
 if (!apiKeyEnv) {
@@ -27,7 +28,7 @@ const sessionState = { activeIndex: 0 };
 const getActiveClient = () => workspaceClients[sessionState.activeIndex].client;
 const server = new McpServer({
     name: "OmniSocials",
-    version: "1.12.0",
+    version: "1.13.0",
 });
 // Register all tools - pass getter function so tools always use the active workspace's client
 registerPostTools(server, getActiveClient);
@@ -35,6 +36,7 @@ registerMediaTools(server, getActiveClient);
 registerAccountTools(server, getActiveClient);
 registerAnalyticsTools(server, getActiveClient);
 registerWebhookTools(server, getActiveClient);
+registerInboxTools(server, getActiveClient);
 registerWorkspaceTools(server, workspaceClients, sessionState);
 // Register prompts
 server.prompt("weekly-report", "Generate a weekly social media performance report", {}, async () => ({

package/build/tools/inbox.d.ts

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

package/build/tools/inbox.js

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import { formatDateTime } from "../client.js";
+const PLATFORM_EMOJI = {
+    instagram: "📸",
+    facebook: "📘",
+    linkedin: "💼",
+};
+export function registerInboxTools(server, getClient) {
+    server.tool("list_inbox_conversations", "List social inbox conversations (Instagram/Facebook DMs, comments, mentions, and LinkedIn company-page comments/mentions), newest activity first. Cursor-paginated: pass the returned cursor to get the next page.", {
+        platform: z
+            .enum(["instagram", "facebook", "linkedin"])
+            .optional()
+            .describe("Filter to one platform"),
+        type: z
+            .enum(["dm", "comment", "mention"])
+            .optional()
+            .describe("Filter to one conversation type"),
+        unread: z
+            .boolean()
+            .optional()
+            .describe("Only conversations with unread incoming messages"),
+        limit: z
+            .number()
+            .optional()
+            .describe("Max conversations per page (1-100, default 25)"),
+        cursor: z
+            .string()
+            .optional()
+            .describe("Pagination cursor from a previous response"),
+    }, async (params) => {
+        const query = {};
+        if (params.platform)
+            query.platform = params.platform;
+        if (params.type)
+            query.type = params.type;
+        if (params.unread !== undefined)
+            query.unread = String(params.unread);
+        if (params.limit !== undefined)
+            query.limit = String(params.limit);
+        if (params.cursor)
+            query.cursor = params.cursor;
+        const result = await getClient().listInboxConversations(query);
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error (${result.error.code}): ${result.error.message}`,
+                    },
+                ],
+            };
+        }
+        const convos = result.data || [];
+        if (!convos.length) {
+            return {
+                content: [{ type: "text", text: "No conversations found." }],
+            };
+        }
+        let md = `## Inbox Conversations (${convos.length})\n\n`;
+        md += `| Platform | Type | From | Unread | Latest message | Conversation ID |\n`;
+        md += `|----------|------|------|--------|----------------|----------------|\n`;
+        for (const c of convos) {
+            const who = c.participant?.name || c.participant?.username || "Unknown";
+            const text = (c.last_message?.text || "").replace(/\n/g, " ").slice(0, 40);
+            md += `| ${PLATFORM_EMOJI[c.platform] || ""} ${c.platform} | ${c.type} | ${who} | ${c.unread_count || 0} | ${text} | \`${c.conversation_id}\` |\n`;
+        }
+        if (result.pagination?.next_cursor) {
+            md += `\n_More available — call list_inbox_conversations again with cursor "${result.pagination.next_cursor}"._`;
+        }
+        return { content: [{ type: "text", text: md }] };
+    });
+    server.tool("get_inbox_conversation", "Get the full message history of one inbox conversation, oldest first. Use the conversation_id from list_inbox_conversations.", {
+        conversation_id: z.string().describe("The conversation ID to fetch"),
+        limit: z
+            .number()
+            .optional()
+            .describe("Max messages per page (1-100, default 50)"),
+        cursor: z.string().optional().describe("Pagination cursor"),
+    }, async ({ conversation_id, limit, cursor }) => {
+        const query = {};
+        if (limit !== undefined)
+            query.limit = String(limit);
+        if (cursor)
+            query.cursor = cursor;
+        const result = await getClient().getInboxMessages(conversation_id, query);
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error (${result.error.code}): ${result.error.message}`,
+                    },
+                ],
+            };
+        }
+        const msgs = result.data || [];
+        if (!msgs.length) {
+            return {
+                content: [
+                    { type: "text", text: "No messages in this conversation." },
+                ],
+            };
+        }
+        let md = `## Conversation \`${conversation_id}\`\n\n`;
+        for (const m of msgs) {
+            const who = m.direction === "outgoing"
+                ? "→ You"
+                : `← ${m.sender?.name || m.sender?.username || "Them"}`;
+            md += `**${who}** _(${formatDateTime(m.timestamp)})_\n${m.text || ""}\n\n`;
+        }
+        if (result.pagination?.next_cursor) {
+            md += `_More messages — call again with cursor "${result.pagination.next_cursor}"._`;
+        }
+        return { content: [{ type: "text", text: md }] };
+    });
+    server.tool("mark_inbox_read", "Mark all incoming messages in a conversation as read.", {
+        conversation_id: z.string().describe("The conversation ID to mark read"),
+    }, async ({ conversation_id }) => {
+        const result = await getClient().markInboxRead(conversation_id);
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error (${result.error.code}): ${result.error.message}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Marked ${result.marked_read ?? 0} message(s) as read in \`${conversation_id}\`.`,
+                },
+            ],
+        };
+    });
+    server.tool("reply_to_inbox", "Reply to an existing inbox conversation (DM, comment, or mention) on Instagram, Facebook, or LinkedIn. You can only reply to conversations that already exist. Direct-message replies must be within the platform's 24-hour messaging window. Each workspace can send up to 1,000 replies per day.", {
+        conversation_id: z.string().describe("The conversation ID to reply to"),
+        text: z.string().describe("The reply text (max 2000 characters)"),
+    }, async ({ conversation_id, text }) => {
+        const result = await getClient().replyToInboxConversation(conversation_id, {
+            text,
+        });
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error (${result.error.code}): ${result.error.message}`,
+                    },
+                ],
+            };
+        }
+        const m = result.data;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Reply sent to \`${conversation_id}\`${m?.platform ? ` on ${m.platform}` : ""}.`,
+                },
+            ],
+        };
+    });
+}

package/build/types.d.ts

@@ -4,6 +4,57 @@ export interface ApiResponse<T = unknown> {
         code: string;
         message: string;
     };
+    pagination?: {
+        next_cursor: string | null;
+        has_more: boolean;
+        limit: number;
+    };
+    conversation_id?: string;
+    marked_read?: number;
+}
+export interface InboxParticipant {
+    id: string;
+    name: string;
+    username: string;
+    profile_picture: string | null;
+}
+export interface InboxConversation {
+    conversation_id: string;
+    platform: "instagram" | "facebook" | "linkedin";
+    type: "dm" | "comment" | "mention";
+    participant: InboxParticipant;
+    unread_count: number;
+    last_message: {
+        id: string;
+        direction: "incoming" | "outgoing";
+        text: string;
+        timestamp: string;
+        is_read: boolean;
+    };
+    post: {
+        id: string | null;
+        caption: string | null;
+        thumbnail: string | null;
+    } | null;
+}
+export interface InboxMessage {
+    id: string;
+    conversation_id: string;
+    platform: string;
+    type: "dm" | "comment" | "mention";
+    direction: "incoming" | "outgoing";
+    text: string;
+    timestamp: string;
+    is_read: boolean;
+    is_replied: boolean;
+    reaction: string | null;
+    parent_comment_id: string | null;
+    sender: InboxParticipant;
+    post: {
+        id: string | null;
+        caption: string | null;
+        thumbnail: string | null;
+    } | null;
 }
 export interface Post {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnisocials/mcp-server",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "MCP server for OmniSocials API - manage social media posts, media, accounts, analytics, and webhooks",
   "type": "module",
   "main": "build/index.js",