@buzzposter/mcp 0.1.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/client.ts
+var BuzzPosterClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+  }
+  async request(method, path, body, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({ message: res.statusText }));
+      const message = typeof errorBody === "object" && errorBody !== null && "message" in errorBody ? String(errorBody.message) : `API error (${res.status})`;
+      throw new Error(`BuzzPoster API error (${res.status}): ${message}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+  // Account
+  async getAccount() {
+    return this.request("GET", "/api/v1/account");
+  }
+  // Social accounts
+  async listAccounts() {
+    return this.request("GET", "/api/v1/accounts");
+  }
+  async checkAccountsHealth() {
+    return this.request("GET", "/api/v1/accounts/health");
+  }
+  // Posts
+  async createPost(data) {
+    return this.request("POST", "/api/v1/posts", data);
+  }
+  async listPosts(params) {
+    return this.request("GET", "/api/v1/posts", void 0, params);
+  }
+  async getPost(id) {
+    return this.request("GET", `/api/v1/posts/${id}`);
+  }
+  async updatePost(id, data) {
+    return this.request("PUT", `/api/v1/posts/${id}`, data);
+  }
+  async deletePost(id) {
+    return this.request("DELETE", `/api/v1/posts/${id}`);
+  }
+  async retryPost(id) {
+    return this.request("POST", `/api/v1/posts/${id}/retry`);
+  }
+  // Analytics
+  async getAnalytics(params) {
+    return this.request("GET", "/api/v1/analytics", void 0, params);
+  }
+  // Inbox
+  async listConversations(params) {
+    return this.request("GET", "/api/v1/inbox/conversations", void 0, params);
+  }
+  async getConversation(id) {
+    return this.request("GET", `/api/v1/inbox/conversations/${id}`);
+  }
+  async replyToConversation(id, message) {
+    return this.request("POST", `/api/v1/inbox/conversations/${id}/reply`, {
+      message
+    });
+  }
+  async listComments(params) {
+    return this.request("GET", "/api/v1/inbox/comments", void 0, params);
+  }
+  async replyToComment(id, message) {
+    return this.request("POST", `/api/v1/inbox/comments/${id}/reply`, {
+      message
+    });
+  }
+  async listReviews(params) {
+    return this.request("GET", "/api/v1/inbox/reviews", void 0, params);
+  }
+  async replyToReview(id, message) {
+    return this.request("POST", `/api/v1/inbox/reviews/${id}/reply`, {
+      message
+    });
+  }
+  // Media
+  async uploadMedia(filename, base64Data, mimeType) {
+    return this.request("POST", "/api/v1/media/upload-base64", {
+      filename,
+      data: base64Data,
+      mimeType
+    });
+  }
+  async listMedia() {
+    return this.request("GET", "/api/v1/media");
+  }
+  async deleteMedia(key) {
+    return this.request("DELETE", `/api/v1/media/${encodeURIComponent(key)}`);
+  }
+  // Newsletter
+  async listSubscribers(params) {
+    return this.request(
+      "GET",
+      "/api/v1/newsletters/subscribers",
+      void 0,
+      params
+    );
+  }
+  async addSubscriber(data) {
+    return this.request("POST", "/api/v1/newsletters/subscribers", data);
+  }
+  async listBroadcasts(params) {
+    return this.request(
+      "GET",
+      "/api/v1/newsletters/broadcasts",
+      void 0,
+      params
+    );
+  }
+  async createBroadcast(data) {
+    return this.request("POST", "/api/v1/newsletters/broadcasts", data);
+  }
+  async updateBroadcast(id, data) {
+    return this.request("PUT", `/api/v1/newsletters/broadcasts/${id}`, data);
+  }
+  async sendBroadcast(id) {
+    return this.request("POST", `/api/v1/newsletters/broadcasts/${id}/send`);
+  }
+  async listTags() {
+    return this.request("GET", "/api/v1/newsletters/tags");
+  }
+  async listSequences() {
+    return this.request("GET", "/api/v1/newsletters/sequences");
+  }
+  async listForms() {
+    return this.request("GET", "/api/v1/newsletters/forms");
+  }
+  // RSS
+  async fetchFeed(url, limit) {
+    const params = { url };
+    if (limit !== void 0) params.limit = String(limit);
+    return this.request("GET", "/api/v1/rss/fetch", void 0, params);
+  }
+  async fetchArticle(url) {
+    return this.request("GET", "/api/v1/rss/article", void 0, { url });
+  }
+};
+
+// src/tools/posts.ts
+import { z } from "zod";
+function registerPostTools(server2, client2) {
+  server2.tool(
+    "post",
+    "Create and publish a post to one or more social media platforms. Supports Twitter, Instagram, LinkedIn, and Facebook with full platform-specific options.",
+    {
+      content: z.string().optional().describe("The text content of the post"),
+      platforms: z.array(z.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach"),
+      platform_specific: z.record(z.record(z.unknown())).optional().describe(
+        "Platform-specific data keyed by platform name. E.g. { twitter: { threadItems: [...] }, instagram: { firstComment: '...' } }"
+      )
+    },
+    async (args) => {
+      const platforms = args.platforms.map((platform) => {
+        const entry = { platform };
+        if (args.platform_specific?.[platform]) {
+          entry.platformSpecificData = args.platform_specific[platform];
+        }
+        return entry;
+      });
+      const body = {
+        content: args.content,
+        platforms,
+        publishNow: true
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client2.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "cross_post",
+    "Post the same content to all connected social media platforms at once.",
+    {
+      content: z.string().describe("The text content to post everywhere"),
+      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach")
+    },
+    async (args) => {
+      const accountsData = await client2.listAccounts();
+      const platforms = (accountsData.accounts ?? []).map(
+        (a) => a.platform
+      );
+      if (platforms.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No connected social accounts found. Connect accounts first."
+            }
+          ]
+        };
+      }
+      const body = {
+        content: args.content,
+        platforms: platforms.map((p) => ({ platform: p })),
+        publishNow: true
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client2.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "schedule_post",
+    "Schedule a post for future publication.",
+    {
+      content: z.string().optional().describe("The text content of the post"),
+      platforms: z.array(z.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      scheduled_for: z.string().describe("ISO 8601 datetime for when to publish, e.g. 2024-01-16T12:00:00"),
+      timezone: z.string().default("UTC").describe("Timezone for the scheduled time, e.g. America/New_York"),
+      media_urls: z.array(z.string()).optional().describe("Media URLs to attach"),
+      platform_specific: z.record(z.record(z.unknown())).optional().describe("Platform-specific data keyed by platform name")
+    },
+    async (args) => {
+      const platforms = args.platforms.map((platform) => {
+        const entry = { platform };
+        if (args.platform_specific?.[platform]) {
+          entry.platformSpecificData = args.platform_specific[platform];
+        }
+        return entry;
+      });
+      const body = {
+        content: args.content,
+        platforms,
+        scheduledFor: args.scheduled_for,
+        timezone: args.timezone
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client2.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "create_draft",
+    "Save a post as a draft without publishing.",
+    {
+      content: z.string().optional().describe("The text content of the draft"),
+      platforms: z.array(z.string()).describe("Platforms this draft is intended for"),
+      media_urls: z.array(z.string()).optional().describe("Media URLs to attach")
+    },
+    async (args) => {
+      const body = {
+        content: args.content,
+        platforms: args.platforms.map((p) => ({ platform: p })),
+        publishNow: false
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client2.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_posts",
+    "List recent posts with their status and platform details.",
+    {
+      status: z.string().optional().describe("Filter by status: published, scheduled, draft, failed"),
+      limit: z.string().optional().describe("Number of posts to return")
+    },
+    async (args) => {
+      const params = {};
+      if (args.status) params.status = args.status;
+      if (args.limit) params.limit = args.limit;
+      const result = await client2.listPosts(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "get_post",
+    "Get detailed information about a specific post.",
+    {
+      post_id: z.string().describe("The ID of the post to retrieve")
+    },
+    async (args) => {
+      const result = await client2.getPost(args.post_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "retry_post",
+    "Retry publishing a post that failed on one or more platforms.",
+    {
+      post_id: z.string().describe("The ID of the post to retry")
+    },
+    async (args) => {
+      const result = await client2.retryPost(args.post_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/accounts.ts
+function registerAccountTools(server2, client2) {
+  server2.tool(
+    "list_accounts",
+    "List all connected social media accounts with their platform, username, and connection status.",
+    {},
+    async () => {
+      const result = await client2.listAccounts();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "check_accounts_health",
+    "Check the health and connection status of all connected social media accounts.",
+    {},
+    async () => {
+      const result = await client2.checkAccountsHealth();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/analytics.ts
+import { z as z2 } from "zod";
+function registerAnalyticsTools(server2, client2) {
+  server2.tool(
+    "get_analytics",
+    "Get performance analytics for your social media posts. Supports filtering by platform and date range.",
+    {
+      platform: z2.string().optional().describe("Filter by platform: twitter, instagram, linkedin, facebook"),
+      from_date: z2.string().optional().describe("Start date for analytics range (ISO 8601)"),
+      to_date: z2.string().optional().describe("End date for analytics range (ISO 8601)")
+    },
+    async (args) => {
+      const params = {};
+      if (args.platform) params.platform = args.platform;
+      if (args.from_date) params.fromDate = args.from_date;
+      if (args.to_date) params.toDate = args.to_date;
+      const result = await client2.getAnalytics(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/inbox.ts
+import { z as z3 } from "zod";
+function registerInboxTools(server2, client2) {
+  server2.tool(
+    "list_conversations",
+    "List DM conversations across all connected social media platforms.",
+    {
+      platform: z3.string().optional().describe("Filter by platform: twitter, instagram, linkedin, facebook")
+    },
+    async (args) => {
+      const params = {};
+      if (args.platform) params.platform = args.platform;
+      const result = await client2.listConversations(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "get_conversation",
+    "Get all messages in a specific DM conversation.",
+    {
+      conversation_id: z3.string().describe("The conversation ID")
+    },
+    async (args) => {
+      const result = await client2.getConversation(args.conversation_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "reply_to_conversation",
+    "Send a reply message in a DM conversation.",
+    {
+      conversation_id: z3.string().describe("The conversation ID to reply to"),
+      message: z3.string().describe("The reply message text")
+    },
+    async (args) => {
+      const result = await client2.replyToConversation(
+        args.conversation_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_comments",
+    "List comments on your social media posts.",
+    {
+      post_id: z3.string().optional().describe("Filter comments by post ID")
+    },
+    async (args) => {
+      const params = {};
+      if (args.post_id) params.postId = args.post_id;
+      const result = await client2.listComments(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "reply_to_comment",
+    "Reply to a comment on one of your posts.",
+    {
+      comment_id: z3.string().describe("The comment ID to reply to"),
+      message: z3.string().describe("The reply text")
+    },
+    async (args) => {
+      const result = await client2.replyToComment(
+        args.comment_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_reviews",
+    "List reviews on your Facebook page.",
+    {},
+    async () => {
+      const result = await client2.listReviews();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "reply_to_review",
+    "Reply to a review on your Facebook page.",
+    {
+      review_id: z3.string().describe("The review ID to reply to"),
+      message: z3.string().describe("The reply text")
+    },
+    async (args) => {
+      const result = await client2.replyToReview(
+        args.review_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/media.ts
+import { z as z4 } from "zod";
+import { readFile } from "fs/promises";
+function registerMediaTools(server2, client2) {
+  server2.tool(
+    "upload_media",
+    "Upload an image or video file from a local file path. Returns a CDN URL that can be used in posts.",
+    {
+      file_path: z4.string().describe("Absolute path to the file on the local filesystem")
+    },
+    async (args) => {
+      const buffer = await readFile(args.file_path);
+      const base64 = buffer.toString("base64");
+      const filename = args.file_path.split("/").pop() ?? "upload";
+      const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+      const mimeMap = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        mp4: "video/mp4",
+        mov: "video/quicktime",
+        avi: "video/x-msvideo",
+        webm: "video/webm",
+        pdf: "application/pdf"
+      };
+      const mimeType = mimeMap[ext] ?? "application/octet-stream";
+      const result = await client2.uploadMedia(filename, base64, mimeType);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "upload_media_base64",
+    "Upload media from base64-encoded data. Returns a CDN URL that can be used in posts.",
+    {
+      filename: z4.string().describe("The filename including extension"),
+      data: z4.string().describe("Base64-encoded file data"),
+      mime_type: z4.string().describe("MIME type of the file, e.g. image/jpeg, video/mp4")
+    },
+    async (args) => {
+      const result = await client2.uploadMedia(
+        args.filename,
+        args.data,
+        args.mime_type
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_media",
+    "List all uploaded media files in your BuzzPoster media library.",
+    {},
+    async () => {
+      const result = await client2.listMedia();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "delete_media",
+    "Delete a media file from your BuzzPoster media library.",
+    {
+      key: z4.string().describe("The key/path of the media file to delete")
+    },
+    async (args) => {
+      await client2.deleteMedia(args.key);
+      return {
+        content: [{ type: "text", text: "Media deleted successfully." }]
+      };
+    }
+  );
+}
+
+// src/tools/newsletter.ts
+import { z as z5 } from "zod";
+function registerNewsletterTools(server2, client2) {
+  server2.tool(
+    "list_subscribers",
+    "List email subscribers from your configured email service provider (Kit, Beehiiv, or Mailchimp).",
+    {
+      page: z5.string().optional().describe("Page number for pagination"),
+      per_page: z5.string().optional().describe("Number of subscribers per page")
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      if (args.per_page) params.perPage = args.per_page;
+      const result = await client2.listSubscribers(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "add_subscriber",
+    "Add a new email subscriber to your mailing list.",
+    {
+      email: z5.string().describe("Email address of the subscriber"),
+      first_name: z5.string().optional().describe("Subscriber's first name"),
+      last_name: z5.string().optional().describe("Subscriber's last name")
+    },
+    async (args) => {
+      const result = await client2.addSubscriber({
+        email: args.email,
+        firstName: args.first_name,
+        lastName: args.last_name
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "create_newsletter",
+    "Create a new newsletter/broadcast draft.",
+    {
+      subject: z5.string().describe("Email subject line"),
+      content: z5.string().describe("HTML content of the newsletter"),
+      preview_text: z5.string().optional().describe("Preview text shown in email clients")
+    },
+    async (args) => {
+      const result = await client2.createBroadcast({
+        subject: args.subject,
+        content: args.content,
+        previewText: args.preview_text
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "update_newsletter",
+    "Update an existing newsletter/broadcast draft.",
+    {
+      broadcast_id: z5.string().describe("The broadcast/newsletter ID to update"),
+      subject: z5.string().optional().describe("Updated subject line"),
+      content: z5.string().optional().describe("Updated HTML content"),
+      preview_text: z5.string().optional().describe("Updated preview text")
+    },
+    async (args) => {
+      const data = {};
+      if (args.subject) data.subject = args.subject;
+      if (args.content) data.content = args.content;
+      if (args.preview_text) data.previewText = args.preview_text;
+      const result = await client2.updateBroadcast(args.broadcast_id, data);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "send_newsletter",
+    "Send a newsletter/broadcast to subscribers. This action cannot be undone.",
+    {
+      broadcast_id: z5.string().describe("The broadcast/newsletter ID to send")
+    },
+    async (args) => {
+      await client2.sendBroadcast(args.broadcast_id);
+      return {
+        content: [{ type: "text", text: "Newsletter sent successfully." }]
+      };
+    }
+  );
+  server2.tool(
+    "list_newsletters",
+    "List all newsletters/broadcasts with their status.",
+    {
+      page: z5.string().optional().describe("Page number for pagination")
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      const result = await client2.listBroadcasts(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_tags",
+    "List all subscriber tags from your email service provider.",
+    {},
+    async () => {
+      const result = await client2.listTags();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_sequences",
+    "List all email sequences/automations from your email service provider.",
+    {},
+    async () => {
+      const result = await client2.listSequences();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "list_forms",
+    "List all signup forms from your email service provider.",
+    {},
+    async () => {
+      const result = await client2.listForms();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/rss.ts
+import { z as z6 } from "zod";
+function registerRssTools(server2, client2) {
+  server2.tool(
+    "fetch_feed",
+    "Fetch and parse entries from an RSS or Atom feed URL. Returns titles, links, descriptions, and dates.",
+    {
+      url: z6.string().describe("The RSS/Atom feed URL to fetch"),
+      limit: z6.number().optional().describe("Maximum number of entries to return (default 10, max 100)")
+    },
+    async (args) => {
+      const result = await client2.fetchFeed(args.url, args.limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "fetch_article",
+    "Extract the full article content from a URL as clean text/markdown. Useful for reading and summarizing articles.",
+    {
+      url: z6.string().describe("The article URL to extract content from")
+    },
+    async (args) => {
+      const result = await client2.fetchArticle(args.url);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/account.ts
+function registerAccountInfoTool(server2, client2) {
+  server2.tool(
+    "get_account",
+    "Get your BuzzPoster account details including name, email, subscription status, ESP configuration, and connected platforms.",
+    {},
+    async () => {
+      const result = await client2.getAccount();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/index.ts
+var apiKey = process.env.BUZZPOSTER_API_KEY;
+var apiUrl = process.env.BUZZPOSTER_API_URL ?? "https://api.buzzposter.com";
+if (!apiKey) {
+  console.error(
+    "Error: BUZZPOSTER_API_KEY environment variable is required."
+  );
+  console.error(
+    "Set it in your Claude Desktop MCP config or export it in your shell."
+  );
+  process.exit(1);
+}
+var client = new BuzzPosterClient({ baseUrl: apiUrl, apiKey });
+var server = new McpServer({
+  name: "buzzposter",
+  version: "0.1.0"
+});
+registerPostTools(server, client);
+registerAccountTools(server, client);
+registerAnalyticsTools(server, client);
+registerInboxTools(server, client);
+registerMediaTools(server, client);
+registerNewsletterTools(server, client);
+registerRssTools(server, client);
+registerAccountInfoTool(server, client);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@buzzposter/mcp",
+  "version": "0.1.0",
+  "description": "BuzzPoster MCP server - Social media, newsletters, and media hosting for Claude Desktop",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "buzzposter-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "social-media",
+    "newsletter",
+    "buzzposter",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "tsx": "^4.19.0",
+    "tsup": "^8.3.0",
+    "@types/node": "^22.0.0"
+  }
+}