posterly-mcp-server 0.8.2 → 0.19.0

package/src/index.ts

@@ -4,25 +4,58 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { PosterlyClient } from './lib/api-client.js';
 import { listAccountsTool } from './tools/list-accounts.js';
+import { disconnectAccountTool } from './tools/disconnect-account.js';
 import { listBrandsTool } from './tools/list-brands.js';
 import { getBrandTool } from './tools/get-brand.js';
 import { listBrandAccountsTool } from './tools/list-brand-accounts.js';
 import { getBrandProfileTool } from './tools/get-brand-profile.js';
 import { createPostTool } from './tools/create-post.js';
+import { createPostsBatchTool } from './tools/create-posts-batch.js';
 import { findSlotTool } from './tools/find-slot.js';
 import { listPostsTool } from './tools/list-posts.js';
 import { uploadMediaTool } from './tools/upload-media.js';
 import { getPostTool } from './tools/get-post.js';
+import { getPostMissingTool } from './tools/get-post-missing.js';
 import { updatePostTool } from './tools/update-post.js';
+import { updatePostStatusTool } from './tools/update-post-status.js';
+import { updatePostReleaseIdTool } from './tools/update-post-release-id.js';
 import { deletePostTool } from './tools/delete-post.js';
+import { deletePostGroupTool } from './tools/delete-post-group.js';
 import { whoamiTool } from './tools/whoami.js';
 import { generateImageTool } from './tools/generate-image.js';
+import { getVideoOptionsTool } from './tools/get-video-options.js';
+import { runVideoFunctionTool } from './tools/run-video-function.js';
+import { generateVideoTool } from './tools/generate-video.js';
+import { getVideoJobTool } from './tools/get-video-job.js';
 import { getAccountAnalyticsTool } from './tools/get-account-analytics.js';
 import { getPostAnalyticsTool } from './tools/get-post-analytics.js';
+import { listGoogleBusinessReviewsTool } from './tools/list-google-business-reviews.js';
+import { getGoogleBusinessReviewLinkTool } from './tools/get-google-business-review-link.js';
+import { auditGoogleBusinessProfileTool } from './tools/audit-google-business-profile.js';
+import { suggestGoogleBusinessReviewReplyTool } from './tools/suggest-google-business-review-reply.js';
+import { replyGoogleBusinessReviewTool } from './tools/reply-google-business-review.js';
+import { deleteGoogleBusinessReviewReplyTool } from './tools/delete-google-business-review-reply.js';
+import { listActivityTool } from './tools/list-activity.js';
+import { listWebhooksTool } from './tools/list-webhooks.js';
+import { createWebhookTool } from './tools/create-webhook.js';
+import { updateWebhookTool } from './tools/update-webhook.js';
+import { deleteWebhookTool } from './tools/delete-webhook.js';
+import { testWebhookTool } from './tools/test-webhook.js';
+import { listPlatformsTool } from './tools/list-platforms.js';
+import { getPlatformSchemaTool } from './tools/get-platform-schema.js';
+import { triggerPlatformHelperTool } from './tools/trigger-platform-helper.js';
+import { getXPostingQuotaTool } from './tools/get-x-posting-quota.js';
+import { createSignedUploadTool } from './tools/create-signed-upload.js';
+import { uploadMediaFromUrlTool } from './tools/upload-media-from-url.js';
+import { getConnectLinkTool } from './tools/get-connect-link.js';
+import { listOAuthClientsTool } from './tools/list-oauth-clients.js';
+import { createOAuthClientTool } from './tools/create-oauth-client.js';
+import { updateOAuthClientTool } from './tools/update-oauth-client.js';
+import { deleteOAuthClientTool } from './tools/delete-oauth-client.js';
 
 const server = new McpServer({
   name: 'posterly',
-  version: '0.8.0',
+  version: '0.19.0',
 });
 
 let client: PosterlyClient;
@@ -63,6 +96,132 @@ server.tool(
   }
 );
 
+server.tool(
+  disconnectAccountTool.name,
+  disconnectAccountTool.description,
+  disconnectAccountTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await disconnectAccountTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getConnectLinkTool.name,
+  getConnectLinkTool.description,
+  getConnectLinkTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getConnectLinkTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  listOAuthClientsTool.name,
+  listOAuthClientsTool.description,
+  listOAuthClientsTool.inputSchema.shape,
+  async () => {
+    try {
+      const text = await listOAuthClientsTool.execute(client);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  createOAuthClientTool.name,
+  createOAuthClientTool.description,
+  createOAuthClientTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await createOAuthClientTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  updateOAuthClientTool.name,
+  updateOAuthClientTool.description,
+  updateOAuthClientTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await updateOAuthClientTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  deleteOAuthClientTool.name,
+  deleteOAuthClientTool.description,
+  deleteOAuthClientTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await deleteOAuthClientTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  listPlatformsTool.name,
+  listPlatformsTool.description,
+  listPlatformsTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await listPlatformsTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getPlatformSchemaTool.name,
+  getPlatformSchemaTool.description,
+  getPlatformSchemaTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getPlatformSchemaTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  triggerPlatformHelperTool.name,
+  triggerPlatformHelperTool.description,
+  triggerPlatformHelperTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await triggerPlatformHelperTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   listBrandsTool.name,
   listBrandsTool.description,
@@ -133,6 +292,20 @@ server.tool(
   }
 );
 
+server.tool(
+  createPostsBatchTool.name,
+  createPostsBatchTool.description,
+  createPostsBatchTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await createPostsBatchTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   findSlotTool.name,
   findSlotTool.description,
@@ -175,6 +348,90 @@ server.tool(
   }
 );
 
+server.tool(
+  uploadMediaFromUrlTool.name,
+  uploadMediaFromUrlTool.description,
+  uploadMediaFromUrlTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await uploadMediaFromUrlTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  createSignedUploadTool.name,
+  createSignedUploadTool.description,
+  createSignedUploadTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await createSignedUploadTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getVideoOptionsTool.name,
+  getVideoOptionsTool.description,
+  getVideoOptionsTool.inputSchema.shape,
+  async () => {
+    try {
+      const text = await getVideoOptionsTool.execute(client);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  runVideoFunctionTool.name,
+  runVideoFunctionTool.description,
+  runVideoFunctionTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await runVideoFunctionTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  generateVideoTool.name,
+  generateVideoTool.description,
+  generateVideoTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await generateVideoTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getVideoJobTool.name,
+  getVideoJobTool.description,
+  getVideoJobTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getVideoJobTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   generateImageTool.name,
   generateImageTool.description,
@@ -203,6 +460,20 @@ server.tool(
   }
 );
 
+server.tool(
+  getPostMissingTool.name,
+  getPostMissingTool.description,
+  getPostMissingTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getPostMissingTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   updatePostTool.name,
   updatePostTool.description,
@@ -217,6 +488,34 @@ server.tool(
   }
 );
 
+server.tool(
+  updatePostStatusTool.name,
+  updatePostStatusTool.description,
+  updatePostStatusTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await updatePostStatusTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  updatePostReleaseIdTool.name,
+  updatePostReleaseIdTool.description,
+  updatePostReleaseIdTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await updatePostReleaseIdTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   deletePostTool.name,
   deletePostTool.description,
@@ -231,6 +530,20 @@ server.tool(
   }
 );
 
+server.tool(
+  deletePostGroupTool.name,
+  deletePostGroupTool.description,
+  deletePostGroupTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await deletePostGroupTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   getAccountAnalyticsTool.name,
   getAccountAnalyticsTool.description,
@@ -259,6 +572,188 @@ server.tool(
   }
 );
 
+server.tool(
+  listGoogleBusinessReviewsTool.name,
+  listGoogleBusinessReviewsTool.description,
+  listGoogleBusinessReviewsTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await listGoogleBusinessReviewsTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getGoogleBusinessReviewLinkTool.name,
+  getGoogleBusinessReviewLinkTool.description,
+  getGoogleBusinessReviewLinkTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getGoogleBusinessReviewLinkTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  auditGoogleBusinessProfileTool.name,
+  auditGoogleBusinessProfileTool.description,
+  auditGoogleBusinessProfileTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await auditGoogleBusinessProfileTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  suggestGoogleBusinessReviewReplyTool.name,
+  suggestGoogleBusinessReviewReplyTool.description,
+  suggestGoogleBusinessReviewReplyTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await suggestGoogleBusinessReviewReplyTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  replyGoogleBusinessReviewTool.name,
+  replyGoogleBusinessReviewTool.description,
+  replyGoogleBusinessReviewTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await replyGoogleBusinessReviewTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  deleteGoogleBusinessReviewReplyTool.name,
+  deleteGoogleBusinessReviewReplyTool.description,
+  deleteGoogleBusinessReviewReplyTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await deleteGoogleBusinessReviewReplyTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  listActivityTool.name,
+  listActivityTool.description,
+  listActivityTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await listActivityTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  listWebhooksTool.name,
+  listWebhooksTool.description,
+  listWebhooksTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await listWebhooksTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  createWebhookTool.name,
+  createWebhookTool.description,
+  createWebhookTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await createWebhookTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  updateWebhookTool.name,
+  updateWebhookTool.description,
+  updateWebhookTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await updateWebhookTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  deleteWebhookTool.name,
+  deleteWebhookTool.description,
+  deleteWebhookTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await deleteWebhookTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  testWebhookTool.name,
+  testWebhookTool.description,
+  testWebhookTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await testWebhookTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  getXPostingQuotaTool.name,
+  getXPostingQuotaTool.description,
+  getXPostingQuotaTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getXPostingQuotaTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 // Start the server
 async function main() {
   const transport = new StdioServerTransport();