@muhammadhamidraza/social-media-mcp-server 1.0.2 → 1.0.3

package/dist/platforms/linkedin.js

@@ -293,6 +293,263 @@ export class LinkedInPlatform {
                     },
                     required: ["recipientId", "message"]
                 }
+            },
+            {
+                name: "linkedin_create_video_post",
+                description: "Post video content to LinkedIn",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        text: {
+                            type: "string",
+                            description: "Post commentary text"
+                        },
+                        videoUrl: {
+                            type: "string",
+                            description: "URL of the video file"
+                        },
+                        title: {
+                            type: "string",
+                            description: "Video title"
+                        },
+                        visibility: {
+                            type: "string",
+                            description: "Post visibility",
+                            enum: ["PUBLIC", "CONNECTIONS"],
+                            default: "PUBLIC"
+                        }
+                    },
+                    required: ["videoUrl"]
+                }
+            },
+            {
+                name: "linkedin_schedule_post",
+                description: "Schedule a post for later publishing",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        text: {
+                            type: "string",
+                            description: "Post content text"
+                        },
+                        scheduledTime: {
+                            type: "number",
+                            description: "Unix timestamp for scheduled publishing"
+                        },
+                        visibility: {
+                            type: "string",
+                            description: "Post visibility",
+                            enum: ["PUBLIC", "CONNECTIONS"],
+                            default: "PUBLIC"
+                        }
+                    },
+                    required: ["text", "scheduledTime"]
+                }
+            },
+            {
+                name: "linkedin_update_post",
+                description: "Update an existing post",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        postUrn: {
+                            type: "string",
+                            description: "LinkedIn post URN"
+                        },
+                        text: {
+                            type: "string",
+                            description: "New post text"
+                        }
+                    },
+                    required: ["postUrn", "text"]
+                }
+            },
+            {
+                name: "linkedin_reply_comment",
+                description: "Reply to a comment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        commentUrn: {
+                            type: "string",
+                            description: "Parent comment URN"
+                        },
+                        text: {
+                            type: "string",
+                            description: "Reply text"
+                        }
+                    },
+                    required: ["commentUrn", "text"]
+                }
+            },
+            {
+                name: "linkedin_delete_comment",
+                description: "Delete a comment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        commentUrn: {
+                            type: "string",
+                            description: "Comment URN to delete"
+                        }
+                    },
+                    required: ["commentUrn"]
+                }
+            },
+            {
+                name: "linkedin_get_conversations",
+                description: "Get message conversations (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        count: {
+                            type: "number",
+                            description: "Number of conversations (default: 10)",
+                            default: 10
+                        }
+                    }
+                }
+            },
+            {
+                name: "linkedin_get_messages",
+                description: "Get messages in a conversation (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        conversationId: {
+                            type: "string",
+                            description: "Conversation ID"
+                        },
+                        count: {
+                            type: "number",
+                            description: "Number of messages (default: 10)",
+                            default: 10
+                        }
+                    },
+                    required: ["conversationId"]
+                }
+            },
+            {
+                name: "linkedin_reply_message",
+                description: "Reply to a message (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        conversationId: {
+                            type: "string",
+                            description: "Conversation ID"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Reply message text"
+                        }
+                    },
+                    required: ["conversationId", "message"]
+                }
+            },
+            {
+                name: "linkedin_get_engagement_report",
+                description: "Get engagement metrics for posts",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        organizationId: {
+                            type: "string",
+                            description: "LinkedIn organization ID"
+                        },
+                        startDate: {
+                            type: "string",
+                            description: "Start date (ISO 8601)"
+                        },
+                        endDate: {
+                            type: "string",
+                            description: "End date (ISO 8601)"
+                        }
+                    },
+                    required: ["organizationId"]
+                }
+            },
+            {
+                name: "linkedin_get_impression_report",
+                description: "Get impression analytics",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        organizationId: {
+                            type: "string",
+                            description: "LinkedIn organization ID"
+                        },
+                        startDate: {
+                            type: "string",
+                            description: "Start date (ISO 8601)"
+                        },
+                        endDate: {
+                            type: "string",
+                            description: "End date (ISO 8601)"
+                        }
+                    },
+                    required: ["organizationId"]
+                }
+            },
+            {
+                name: "linkedin_get_visitor_analytics",
+                description: "Get profile visitor statistics",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        organizationId: {
+                            type: "string",
+                            description: "LinkedIn organization ID"
+                        }
+                    },
+                    required: ["organizationId"]
+                }
+            },
+            {
+                name: "linkedin_get_connection_requests",
+                description: "Get pending connection requests (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        count: {
+                            type: "number",
+                            description: "Number of requests (default: 10)",
+                            default: 10
+                        }
+                    }
+                }
+            },
+            {
+                name: "linkedin_accept_connection",
+                description: "Accept a connection request (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        invitationId: {
+                            type: "string",
+                            description: "Invitation ID"
+                        }
+                    },
+                    required: ["invitationId"]
+                }
+            },
+            {
+                name: "linkedin_send_connection_request",
+                description: "Send a connection request (requires partnership program)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        personId: {
+                            type: "string",
+                            description: "LinkedIn person ID"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Optional connection message"
+                        }
+                    },
+                    required: ["personId"]
+                }
             }
         ];
     }
@@ -337,6 +594,34 @@ export class LinkedInPlatform {
                 return this.getConnections(args);
             case "linkedin_send_message":
                 return this.sendMessage(args);
+            case "linkedin_create_video_post":
+                return this.createVideoPost(args);
+            case "linkedin_schedule_post":
+                return this.schedulePost(args);
+            case "linkedin_update_post":
+                return this.updatePost(args);
+            case "linkedin_reply_comment":
+                return this.replyComment(args);
+            case "linkedin_delete_comment":
+                return this.deleteComment(args);
+            case "linkedin_get_conversations":
+                return this.getConversations(args);
+            case "linkedin_get_messages":
+                return this.getMessages(args);
+            case "linkedin_reply_message":
+                return this.replyMessage(args);
+            case "linkedin_get_engagement_report":
+                return this.getEngagementReport(args);
+            case "linkedin_get_impression_report":
+                return this.getImpressionReport(args);
+            case "linkedin_get_visitor_analytics":
+                return this.getVisitorAnalytics(args);
+            case "linkedin_get_connection_requests":
+                return this.getConnectionRequests(args);
+            case "linkedin_accept_connection":
+                return this.acceptConnection(args);
+            case "linkedin_send_connection_request":
+                return this.sendConnectionRequest(args);
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -695,5 +980,272 @@ export class LinkedInPlatform {
             };
         }
     }
+    async createVideoPost(args) {
+        try {
+            const personId = await this.getPersonId();
+            const visibility = args.visibility || "PUBLIC";
+            const body = {
+                author: `urn:li:person:${personId}`,
+                lifecycleState: "PUBLISHED",
+                specificContent: {
+                    "com.linkedin.ugc.ShareContent": {
+                        shareCommentary: {
+                            text: args.text || ""
+                        },
+                        shareMediaCategory: "VIDEO",
+                        media: [{
+                                status: "READY",
+                                originalUrl: args.videoUrl,
+                                title: {
+                                    text: args.title || "Video"
+                                }
+                            }]
+                    }
+                },
+                visibility: {
+                    "com.linkedin.ugc.MemberNetworkVisibility": visibility
+                }
+            };
+            const data = await this.apiRequest("/ugcPosts", {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: `Video post created successfully! ID: ${data?.id || "unknown"}` }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to create LinkedIn video post: ${error}`);
+        }
+    }
+    async schedulePost(args) {
+        try {
+            const personId = await this.getPersonId();
+            const visibility = args.visibility || "PUBLIC";
+            const body = {
+                author: `urn:li:person:${personId}`,
+                lifecycleState: "PUBLISHED",
+                specificContent: {
+                    "com.linkedin.ugc.ShareContent": {
+                        shareCommentary: {
+                            text: args.text
+                        },
+                        shareMediaCategory: "NONE"
+                    }
+                },
+                visibility: {
+                    "com.linkedin.ugc.MemberNetworkVisibility": visibility
+                },
+                publishedAt: args.scheduledTime * 1000
+            };
+            const data = await this.apiRequest("/ugcPosts", {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: `Post scheduled successfully! ID: ${data?.id || "unknown"}` }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to schedule LinkedIn post: ${error}`);
+        }
+    }
+    async updatePost(args) {
+        try {
+            const body = {
+                specificContent: {
+                    "com.linkedin.ugc.ShareContent": {
+                        shareCommentary: {
+                            text: args.text
+                        }
+                    }
+                }
+            };
+            await this.apiRequest(`/ugcPosts/${args.postUrn}`, {
+                method: "PATCH",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: "Post updated successfully!" }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to update LinkedIn post: ${error}`);
+        }
+    }
+    async replyComment(args) {
+        try {
+            const personId = await this.getPersonId();
+            const body = {
+                actor: `urn:li:person:${personId}`,
+                parentComment: args.commentUrn,
+                message: {
+                    text: args.text
+                }
+            };
+            const data = await this.apiRequest("/socialActions/{id}/comments", {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: `Reply posted successfully! ID: ${data?.id || "unknown"}` }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to reply to LinkedIn comment: ${error}`);
+        }
+    }
+    async deleteComment(args) {
+        try {
+            await this.apiRequest(`/socialActions/{id}/comments/${args.commentUrn}`, {
+                method: "DELETE"
+            });
+            return {
+                content: [{ type: "text", text: "Comment deleted successfully!" }]
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to delete LinkedIn comment: ${error}`);
+        }
+    }
+    async getConversations(args) {
+        try {
+            const count = args.count || 10;
+            const data = await this.apiRequest(`/conversations?count=${count}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Conversations API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async getMessages(args) {
+        try {
+            const count = args.count || 10;
+            const data = await this.apiRequest(`/conversations/${args.conversationId}/messages?count=${count}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Messages API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async replyMessage(args) {
+        try {
+            const body = {
+                body: args.message
+            };
+            const data = await this.apiRequest(`/conversations/${args.conversationId}/messages`, {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: `Reply sent successfully! ID: ${data?.id || "unknown"}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Reply message API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async getEngagementReport(args) {
+        try {
+            const data = await this.apiRequest(`/organizationalEntityShareStatistics?q=organizationalEntity&organizationalEntity=urn:li:organization:${args.organizationId}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Engagement analytics may require additional permissions", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async getImpressionReport(args) {
+        try {
+            const data = await this.apiRequest(`/organizationPageStatistics?q=organization&organization=urn:li:organization:${args.organizationId}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Impression analytics may require additional permissions", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async getVisitorAnalytics(args) {
+        try {
+            const data = await this.apiRequest(`/organizationPageStatistics?q=organization&organization=urn:li:organization:${args.organizationId}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Visitor analytics may require additional permissions", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async getConnectionRequests(args) {
+        try {
+            const count = args.count || 10;
+            const data = await this.apiRequest(`/invitations?count=${count}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Connection requests API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async acceptConnection(args) {
+        try {
+            const body = {
+                action: "accept"
+            };
+            await this.apiRequest(`/invitations/${args.invitationId}`, {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: "Connection request accepted successfully!" }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Accept connection API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
+    async sendConnectionRequest(args) {
+        try {
+            const body = {
+                invitee: `urn:li:person:${args.personId}`,
+                message: args.message || ""
+            };
+            const data = await this.apiRequest("/invitations", {
+                method: "POST",
+                body: JSON.stringify(body)
+            });
+            return {
+                content: [{ type: "text", text: `Connection request sent successfully! ID: ${data?.id || "unknown"}` }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Send connection request API requires LinkedIn Partnership Program access", details: String(error) }, null, 2) }]
+            };
+        }
+    }
 }
 //# sourceMappingURL=linkedin.js.map